diff --git a/.travis.yml b/.travis.yml
index 7f290e6..032bf9d 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,7 +5,14 @@
   - 5.3
   - 5.4
 
+before_script:
+  - pyrus channel-discover pear.php-tools.net
+  - pyrus install http://pear.php-tools.net/get/vfsStream-0.11.2.tgz
+  - phpenv rehash
+
+script: phpunit --configuration tests/phpunit.xml 
+
 branches:
-  except:
+  only:
     - develop
-    - master
+    - master
\ No newline at end of file
diff --git a/application/config/config.php b/application/config/config.php
index 4ad9d1d..2ffbb66 100644
--- a/application/config/config.php
+++ b/application/config/config.php
@@ -297,12 +297,14 @@
 | 'cookie_domain' = Set to .your-domain.com for site-wide cookies
 | 'cookie_path'   =  Typically will be a forward slash
 | 'cookie_secure' =  Cookies will only be set if a secure HTTPS connection exists.
+| 'cookie_httponly' = Cookie will only be accessible via HTTP(S) (no javascript) 
 |
 */
 $config['cookie_prefix']	= "";
 $config['cookie_domain']	= "";
 $config['cookie_path']		= "/";
 $config['cookie_secure']	= FALSE;
+$config['cookie_httponly'] 	= FALSE;
 
 /*
 |--------------------------------------------------------------------------
diff --git a/license.rst b/license.rst
deleted file mode 100644
index 17179a9..0000000
--- a/license.rst
+++ /dev/null
@@ -1,245 +0,0 @@
-###################################
-Open Software License ("OSL") v 3.0
-###################################
-
-This Open Software License (the "License") applies to any original work of
-authorship (the "Original Work") whose owner (the "Licensor") has placed the
-following licensing notice adjacent to the copyright notice for the Original
-Work:
-
-*Licensed under the Open Software License version 3.0*
-
-
-*****************************
-1) Grant of Copyright License
-*****************************
-
-Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable
-license, for the duration of the copyright, to do the following:
-
-	*a)* to reproduce the Original Work in copies, either alone or as part of
-	a collective work;
-
-	*b)* to translate, adapt, alter, transform, modify, or arrange the
-	Original Work, thereby creating derivative works ("Derivative Works")
-	based upon the Original Work;
-
-	*c)* to distribute or communicate copies of the Original Work and
-	Derivative Works to the public, *with the proviso that copies of Original
-	Work or Derivative Works that You distribute or communicate shall be
-	licensed under this Open Software License*;
-
-	*d)* to perform the Original Work publicly; and
-
-	*e)* to display the Original Work publicly.
-
-
-**************************
-2) Grant of Patent License
-**************************
-
-Licensor grants You a worldwide, royalty-free, non-exclusive, sublicensable
-license, under patent claims owned or controlled by the Licensor that are
-embodied in the Original Work as furnished by the Licensor, for the duration
-of the patents, to make, use, sell, offer for sale, have made, and import the
-Original Work and Derivative Works.
-
-
-*******************************
-3) Grant of Source Code License
-*******************************
-
-The term "Source Code" means the preferred form of the Original Work for
-making modifications to it and all available documentation describing how to
-modify the Original Work. Licensor agrees to provide a machine-readable copy
-of the Source Code of the Original Work along with each copy of the Original
-Work that Licensor distributes. Licensor reserves the right to satisfy this
-obligation by placing a machine-readable copy of the Source Code in an
-information repository reasonably calculated to permit inexpensive and
-convenient access by You for as long as Licensor continues to distribute the
-Original Work.
-
-
-********************************
-4) Exclusions From License Grant
-********************************
-
-Neither the names of Licensor, nor the names of any contributors to the
-Original Work, nor any of their trademarks or service marks, may be used to
-endorse or promote products derived from this Original Work without express
-prior permission of the Licensor. Except as expressly stated herein, nothing
-in this License grants any license to Licensor's trademarks, copyrights,
-patents, trade secrets or any other intellectual property. No patent license
-is granted to make, use, sell, offer for sale, have made, or import
-embodiments of any patent claims other than the licensed claims defined in
-Section 2) No license is granted to the trademarks of Licensor even if such
-marks are included in the Original Work. Nothing in this License shall be
-interpreted to prohibit Licensor from licensing under terms different from
-this License any Original Work that Licensor otherwise would have a right to
-license.
-
-
-**********************
-5) External Deployment
-**********************
-
-The term "External Deployment" means the use, distribution, or communication
-of the Original Work or Derivative Works in any way such that the Original
-Work or Derivative Works may be used by anyone other than You, whether those
-works are distributed or communicated to those persons or made available as an
-application intended for use over a network. As an express condition for the
-grants of license hereunder, You must treat any External Deployment by You of
-the Original Work or a Derivative Work as a distribution under section 1(c).
-
-
-*********************
-6) Attribution Rights
-*********************
-
-You must retain, in the Source Code of any Derivative Works that You create,
-all copyright, patent, or trademark notices from the Source Code of the
-Original Work, as well as any notices of licensing and any descriptive text
-identified therein as an "Attribution Notice." You must cause the Source Code
-for any Derivative Works that You create to carry a prominent Attribution
-Notice reasonably calculated to inform recipients that You have modified the
-Original Work.
-
-
-****************************************************
-7) Warranty of Provenance and Disclaimer of Warranty
-****************************************************
-
-Licensor warrants that the copyright in and to the Original Work and the
-patent rights granted herein by Licensor are owned by the Licensor or are
-sublicensed to You under the terms of this License with the permission of the
-contributor(s) of those copyrights and patent rights. Except as expressly
-stated in the immediately preceding sentence, the Original Work is provided
-under this License on an "AS IS" BASIS and WITHOUT WARRANTY, either express or
-implied, including, without limitation, the warranties of non-infringement,
-merchantability or fitness for a particular purpose. THE ENTIRE RISK AS TO THE
-QUALITY OF THE ORIGINAL WORK IS WITH YOU. This DISCLAIMER OF WARRANTY
-constitutes an essential part of this License. No license to the Original Work
-is granted by this License except under this disclaimer.
-
-
-**************************
-8) Limitation of Liability
-**************************
-
-Under no circumstances and under no legal theory, whether in tort (including
-negligence), contract, or otherwise, shall the Licensor be liable to anyone
-for any indirect, special, incidental, or consequential damages of any
-character arising as a result of this License or the use of the Original Work
-including, without limitation, damages for loss of goodwill, work stoppage,
-computer failure or malfunction, or any and all other commercial damages or
-losses. This limitation of liability shall not apply to the extent applicable
-law prohibits such limitation.
-
-
-*****************************
-9) Acceptance and Termination
-*****************************
-
-If, at any time, You expressly assented to this License, that assent indicates
-your clear and irrevocable acceptance of this License and all of its terms and
-conditions. If You distribute or communicate copies of the Original Work or a
-Derivative Work, You must make a reasonable effort under the circumstances to
-obtain the express assent of recipients to the terms of this License. This
-License conditions your rights to undertake the activities listed in Section
-1, including your right to create Derivative Works based upon the Original
-Work, and doing so without honoring these terms and conditions is prohibited
-by copyright law and international treaty. Nothing in this License is intended
-to affect copyright exceptions and limitations (including "fair use" or "fair
-dealing"). This License shall terminate immediately and You may no longer
-exercise any of the rights granted to You by this License upon your failure to
-honor the conditions in Section 1(c).
-
-
-*********************************
-10) Termination for Patent Action
-*********************************
-
-This License shall terminate automatically and You may no longer exercise any
-of the rights granted to You by this License as of the date You commence an
-action, including a cross-claim or counterclaim, against Licensor or any
-licensee alleging that the Original Work infringes a patent. This termination
-provision shall not apply for an action alleging patent infringement by
-combinations of the Original Work with other software or hardware.
-
-
-*****************************************
-11) Jurisdiction, Venue and Governing Law
-*****************************************
-
-Any action or suit relating to this License may be brought only in the courts
-of a jurisdiction wherein the Licensor resides or in which Licensor conducts
-its primary business, and under the laws of that jurisdiction excluding its
-conflict-of-law provisions. The application of the United Nations Convention
-on Contracts for the International Sale of Goods is expressly excluded. Any
-use of the Original Work outside the scope of this License or after its
-termination shall be subject to the requirements and penalties of copyright or
-patent law in the appropriate jurisdiction. This section shall survive the
-termination of this License.
-
-
-*******************
-12) Attorneys' Fees
-*******************
-
-In any action to enforce the terms of this License or seeking damages relating
-thereto, the prevailing party shall be entitled to recover its costs and
-expenses, including, without limitation, reasonable attorneys' fees and costs
-incurred in connection with such action, including any appeal of such action.
-This section shall survive the termination of this License.
-
-
-*****************
-13) Miscellaneous
-*****************
-
-If any provision of this License is held to be unenforceable, such provision
-shall be reformed only to the extent necessary to make it enforceable.
-
-
-***************************************
-14) Definition of "You" in This License
-***************************************
-
-"You" throughout this License, whether in upper or lower case, means an
-individual or a legal entity exercising rights under, and complying with all
-of the terms of, this License. For legal entities, "You" includes any entity
-that controls, is controlled by, or is under common control with you. For
-purposes of this definition, "control" means (i) the power, direct or
-indirect, to cause the direction or management of such entity, whether by
-contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
-outstanding shares, or (iii) beneficial ownership of such entity.
-
-
-****************
-15) Right to Use
-****************
-
-You may use the Original Work in all ways not otherwise restricted or
-conditioned by this License or by law, and Licensor promises not to interfere
-with or be responsible for such uses by You.
-
-
-********************************
-16) Modification of This License
-********************************
-
-This License is Copyright © 2005 Lawrence Rosen. Permission is granted to
-copy, distribute, or communicate this License without modification. Nothing in
-this License permits You to modify this License as applied to the Original
-Work or to Derivative Works. However, You may modify the text of this License
-and copy, distribute or communicate your modified version (the "Modified
-License") and apply it to other original works of authorship subject to the
-following conditions: (i) You may not indicate in any way that your Modified
-License is the "Open Software License" or "OSL" and you may not use those
-names in the name of your Modified License; (ii) You must replace the notice
-specified in the first paragraph above with the notice "Licensed under <insert
-your license name here>" or with a notice of your own that is not confusingly
-similar to the notice in this License; and (iii) You may not claim that your
-original works are open source software unless your Modified License has been
-approved by Open Source Initiative (OSI) and You comply with its license
-review and certification process.
\ No newline at end of file
diff --git a/system/core/Config.php b/system/core/Config.php
index 1e149d0..91826bd 100755
--- a/system/core/Config.php
+++ b/system/core/Config.php
@@ -76,7 +76,7 @@
 		log_message('debug', 'Config Class Initialized');
 
 		// Set the base_url automatically if none was provided
-		if ($this->config['base_url'] == '')
+		if (empty($this->config['base_url']))
 		{
 			if (isset($_SERVER['HTTP_HOST']))
 			{
diff --git a/system/core/Input.php b/system/core/Input.php
index 901b414..6e68859 100755
--- a/system/core/Input.php
+++ b/system/core/Input.php
@@ -228,7 +228,7 @@
 	/**
 	* Set cookie
 	*
-	* Accepts six parameter, or you can submit an associative
+	* Accepts seven parameters, or you can submit an associative
 	* array in the first parameter containing all the values.
 	*
 	* @param	mixed
@@ -238,14 +238,15 @@
 	* @param	string	the cookie path
 	* @param	string	the cookie prefix
 	* @param	bool	true makes the cookie secure
+	* @param	bool	true makes the cookie accessible via http(s) only (no javascript)
 	* @return	void
 	*/
-	public function set_cookie($name = '', $value = '', $expire = '', $domain = '', $path = '/', $prefix = '', $secure = FALSE)
+	public function set_cookie($name = '', $value = '', $expire = '', $domain = '', $path = '/', $prefix = '', $secure = FALSE, $httponly = FALSE)
 	{
 		if (is_array($name))
 		{
 			// always leave 'name' in last place, as the loop will break otherwise, due to $$item
-			foreach (array('value', 'expire', 'domain', 'path', 'prefix', 'secure', 'name') as $item)
+			foreach (array('value', 'expire', 'domain', 'path', 'prefix', 'secure', 'httponly', 'name') as $item)
 			{
 				if (isset($name[$item]))
 				{
@@ -270,6 +271,10 @@
 		{
 			$secure = config_item('cookie_secure');
 		}
+		if ($httponly == FALSE && config_item('cookie_httponly') != FALSE)
+		{
+			$httponly = config_item('cookie_httponly');
+		}
 
 		if ( ! is_numeric($expire))
 		{
@@ -280,7 +285,7 @@
 			$expire = ($expire > 0) ? time() + $expire : 0;
 		}
 
-		setcookie($prefix.$name, $value, $expire, $path, $domain, $secure);
+		setcookie($prefix.$name, $value, $expire, $path, $domain, $secure, $httponly);
 	}
 
 	// --------------------------------------------------------------------
diff --git a/system/core/Security.php b/system/core/Security.php
index cd8a610..ac39ce9 100755
--- a/system/core/Security.php
+++ b/system/core/Security.php
@@ -196,7 +196,15 @@
 			return FALSE;
 		}
 
-		setcookie($this->_csrf_cookie_name, $this->_csrf_hash, $expire, config_item('cookie_path'), config_item('cookie_domain'), $secure_cookie);
+		setcookie(
+			$this->_csrf_cookie_name, 
+			$this->_csrf_hash, 
+			$expire, 
+			config_item('cookie_path'), 
+			config_item('cookie_domain'), 
+			$secure_cookie,
+			config_item('cookie_httponly')
+		);
 		log_message('debug', 'CRSF cookie Set');
 
 		return $this;
diff --git a/system/core/URI.php b/system/core/URI.php
index 4a2e87c..48bb7ae 100755
--- a/system/core/URI.php
+++ b/system/core/URI.php
@@ -22,7 +22,6 @@
  * @license		http://opensource.org/licenses/OSL-3.0 Open Software License (OSL 3.0)
  * @link		http://codeigniter.com
  * @since		Version 1.0
- * @filesource
  */
 
 // ------------------------------------------------------------------------
@@ -93,7 +92,7 @@
 		if (strtoupper($this->config->item('uri_protocol')) === 'AUTO')
 		{
 			// Is the request coming from the command line?
-			if (php_sapi_name() === 'cli' OR defined('STDIN'))
+			if ($this->_is_cli_request())
 			{
 				$this->_set_uri_string($this->_parse_cli_args());
 				return;
@@ -227,6 +226,21 @@
 	}
 
 	// --------------------------------------------------------------------
+	
+	/**
+	 * Is cli Request?
+	 *
+	 * Duplicate of function from the Input class to test to see if a request was made from the command line
+	 *
+	 * @return 	boolean
+	 */
+	protected function _is_cli_request()
+	{
+		return (php_sapi_name() == 'cli') OR defined('STDIN');
+	}
+
+	
+	// --------------------------------------------------------------------
 
 	/**
 	 * Parse cli arguments
diff --git a/system/database/DB_active_rec.php b/system/database/DB_active_rec.php
index 7567096..35164a7 100644
--- a/system/database/DB_active_rec.php
+++ b/system/database/DB_active_rec.php
@@ -214,6 +214,7 @@
 
 		$sql = $this->protect_identifiers($type.'('.trim($select).')').' AS '.$this->protect_identifiers(trim($alias));
 		$this->ar_select[] = $sql;
+		$this->ar_no_escape[] = NULL;
 
 		if ($this->ar_caching === TRUE)
 		{
diff --git a/system/database/drivers/cubrid/cubrid_driver.php b/system/database/drivers/cubrid/cubrid_driver.php
index 2447073..7b468bc 100644
--- a/system/database/drivers/cubrid/cubrid_driver.php
+++ b/system/database/drivers/cubrid/cubrid_driver.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * CUBRID Database Adapter Class
  *
@@ -42,39 +40,35 @@
  */
 class CI_DB_cubrid_driver extends CI_DB {
 
-	// Default CUBRID Broker port. Will be used unless user
-	// explicitly specifies another one.
-	const DEFAULT_PORT = 33000;
-
-	var $dbdriver = 'cubrid';
+	public $dbdriver = 'cubrid';
 
 	// The character used for escaping - no need in CUBRID
-	var	$_escape_char = '';
+	protected $_escape_char = '';
 
 	// clause and character used for LIKE escape sequences - not used in CUBRID
-	var $_like_escape_str = '';
-	var $_like_escape_chr = '';
+	protected $_like_escape_str = '';
+	protected $_like_escape_chr = '';
 
 	/**
 	 * The syntax to count rows is slightly different across different
 	 * database engines, so this string appears in each driver and is
 	 * used for the count_all() and count_all_results() functions.
 	 */
-	var $_count_string = 'SELECT COUNT(*) AS ';
-	var $_random_keyword = ' RAND()'; // database specific random keyword
+	protected $_count_string = 'SELECT COUNT(*) AS ';
+	protected $_random_keyword = ' RAND()'; // database specific random keyword
 
 	/**
 	 * Non-persistent database connection
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_connect()
+	public function db_connect()
 	{
 		// If no port is defined by the user, use the default value
 		if ($this->port == '')
 		{
-			$this->port = self::DEFAULT_PORT;
+			// Default CUBRID Broker port
+			$this->port = 33000;
 		}
 
 		$conn = cubrid_connect($this->hostname, $this->port, $this->database, $this->username, $this->password);
@@ -101,6 +95,7 @@
 
 	/**
 	 * Persistent database connection
+	 *
 	 * In CUBRID persistent DB connection is supported natively in CUBRID
 	 * engine which can be configured in the CUBRID Broker configuration
 	 * file by setting the CCI_PCONNECT parameter to ON. In that case, all
@@ -109,10 +104,9 @@
 	 * @cubrid_connect function will establish persisten connection
 	 * considering that the CCI_PCONNECT is ON.
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_pconnect()
+	public function db_pconnect()
 	{
 		return $this->db_connect();
 	}
@@ -125,10 +119,9 @@
 	 * Keep / reestablish the db connection if no queries have been
 	 * sent for a length of time exceeding the server's idle timeout
 	 *
-	 * @access	public
 	 * @return	void
 	 */
-	function reconnect()
+	public function reconnect()
 	{
 		if (cubrid_ping($this->conn_id) === FALSE)
 		{
@@ -141,10 +134,9 @@
 	/**
 	 * Select the database
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_select()
+	public function db_select()
 	{
 		// In CUBRID there is no need to select a database as the database
 		// is chosen at the connection time.
@@ -172,11 +164,10 @@
 	/**
 	 * Execute the query
 	 *
-	 * @access	private called by the base class
 	 * @param	string	an SQL query
 	 * @return	resource
 	 */
-	function _execute($sql)
+	protected function _execute($sql)
 	{
 		$sql = $this->_prep_query($sql);
 		return @cubrid_query($sql, $this->conn_id);
@@ -189,11 +180,10 @@
 	 *
 	 * If needed, each database adapter can prep the query string
 	 *
-	 * @access	private called by execute()
 	 * @param	string	an SQL query
 	 * @return	string
 	 */
-	function _prep_query($sql)
+	protected function _prep_query($sql)
 	{
 		// No need to prepare
 		return $sql;
@@ -204,10 +194,9 @@
 	/**
 	 * Begin Transaction
 	 *
-	 * @access	public
 	 * @return	bool
 	 */
-	function trans_begin($test_mode = FALSE)
+	public function trans_begin($test_mode = FALSE)
 	{
 		if ( ! $this->trans_enabled)
 		{
@@ -238,10 +227,9 @@
 	/**
 	 * Commit Transaction
 	 *
-	 * @access	public
 	 * @return	bool
 	 */
-	function trans_commit()
+	public function trans_commit()
 	{
 		if ( ! $this->trans_enabled)
 		{
@@ -269,10 +257,9 @@
 	/**
 	 * Rollback Transaction
 	 *
-	 * @access	public
 	 * @return	bool
 	 */
-	function trans_rollback()
+	public function trans_rollback()
 	{
 		if ( ! $this->trans_enabled)
 		{
@@ -300,12 +287,11 @@
 	/**
 	 * Escape String
 	 *
-	 * @access	public
 	 * @param	string
 	 * @param	bool	whether or not the string will be used in a LIKE condition
 	 * @return	string
 	 */
-	function escape_str($str, $like = FALSE)
+	public function escape_str($str, $like = FALSE)
 	{
 		if (is_array($str))
 		{
@@ -352,10 +338,9 @@
 	/**
 	 * Insert ID
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	int
 	 */
-	function insert_id()
+	public function insert_id()
 	{
 		return @cubrid_insert_id($this->conn_id);
 	}
@@ -368,11 +353,10 @@
 	 * Generates a platform-specific query string that counts all records in
 	 * the specified table
 	 *
-	 * @access	public
 	 * @param	string
-	 * @return	string
+	 * @return	int
 	 */
-	function count_all($table = '')
+	public function count_all($table = '')
 	{
 		if ($table == '')
 		{
@@ -397,11 +381,10 @@
 	 *
 	 * Generates a platform-specific query string so that the table names can be fetched
 	 *
-	 * @access	private
-	 * @param	boolean
+	 * @param	bool
 	 * @return	string
 	 */
-	function _list_tables($prefix_limit = FALSE)
+	protected function _list_tables($prefix_limit = FALSE)
 	{
 		$sql = "SHOW TABLES";
 
@@ -420,11 +403,10 @@
 	 *
 	 * Generates a platform-specific query string so that the column names can be fetched
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @return	string
 	 */
-	function _list_columns($table = '')
+	protected function _list_columns($table = '')
 	{
 		return 'SHOW COLUMNS FROM '.$this->protect_identifiers($table, TRUE, NULL, FALSE);
 	}
@@ -436,11 +418,10 @@
 	 *
 	 * Generates a platform-specific query so that the column data can be retrieved
 	 *
-	 * @access	public
 	 * @param	string	the table name
-	 * @return	object
+	 * @return	string
 	 */
-	function _field_data($table)
+	protected function _field_data($table)
 	{
 		return "SELECT * FROM ".$table." LIMIT 1";
 	}
@@ -465,11 +446,10 @@
 	 *
 	 * This function escapes column and table names
 	 *
-	 * @access	private
 	 * @param	string
 	 * @return	string
 	 */
-	function _escape_identifiers($item)
+	public function _escape_identifiers($item)
 	{
 		if ($this->_escape_char == '')
 		{
@@ -508,11 +488,10 @@
 	 * This function implicitly groups FROM tables so there is no confusion
 	 * about operator precedence in harmony with SQL standards
 	 *
-	 * @access	public
-	 * @param	type
-	 * @return	type
+	 * @param	array
+	 * @return	string
 	 */
-	function _from_tables($tables)
+	protected function _from_tables($tables)
 	{
 		if ( ! is_array($tables))
 		{
@@ -529,13 +508,12 @@
 	 *
 	 * Generates a platform-specific insert string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the insert keys
 	 * @param	array	the insert values
 	 * @return	string
 	 */
-	function _insert($table, $keys, $values)
+	protected function _insert($table, $keys, $values)
 	{
 		return "INSERT INTO ".$table." (\"".implode('", "', $keys)."\") VALUES (".implode(', ', $values).")";
 	}
@@ -548,13 +526,12 @@
 	 *
 	 * Generates a platform-specific replace string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the insert keys
 	 * @param	array	the insert values
 	 * @return	string
 	 */
-	function _replace($table, $keys, $values)
+	protected function _replace($table, $keys, $values)
 	{
 		return "REPLACE INTO ".$table." (\"".implode('", "', $keys)."\") VALUES (".implode(', ', $values).")";
 	}
@@ -566,13 +543,12 @@
 	 *
 	 * Generates a platform-specific insert string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the insert keys
 	 * @param	array	the insert values
 	 * @return	string
 	 */
-	function _insert_batch($table, $keys, $values)
+	protected function _insert_batch($table, $keys, $values)
 	{
 		return "INSERT INTO ".$table." (\"".implode('", "', $keys)."\") VALUES ".implode(', ', $values);
 	}
@@ -585,7 +561,6 @@
 	 *
 	 * Generates a platform-specific update string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the update data
 	 * @param	array	the where clause
@@ -593,7 +568,7 @@
 	 * @param	array	the limit clause
 	 * @return	string
 	 */
-	function _update($table, $values, $where, $orderby = array(), $limit = FALSE)
+	protected function _update($table, $values, $where, $orderby = array(), $limit = FALSE)
 	{
 		foreach ($values as $key => $val)
 		{
@@ -621,13 +596,12 @@
 	 *
 	 * Generates a platform-specific batch update string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the update data
 	 * @param	array	the where clause
 	 * @return	string
 	 */
-	function _update_batch($table, $values, $index, $where = NULL)
+	protected function _update_batch($table, $values, $index, $where = NULL)
 	{
 		$ids = array();
 		$where = ($where != '' AND count($where) >=1) ? implode(" ", $where).' AND ' : '';
@@ -668,7 +642,6 @@
 
 	// --------------------------------------------------------------------
 
-
 	/**
 	 * Truncate statement
 	 *
@@ -676,11 +649,10 @@
 	 * If the database does not support the truncate() command
 	 * This function maps to "DELETE FROM table"
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @return	string
 	 */
-	function _truncate($table)
+	protected function _truncate($table)
 	{
 		return "TRUNCATE ".$table;
 	}
@@ -692,13 +664,12 @@
 	 *
 	 * Generates a platform-specific delete string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the where clause
 	 * @param	string	the limit clause
 	 * @return	string
 	 */
-	function _delete($table, $where = array(), $like = array(), $limit = FALSE)
+	protected function _delete($table, $where = array(), $like = array(), $limit = FALSE)
 	{
 		$conditions = '';
 
@@ -726,13 +697,12 @@
 	 *
 	 * Generates a platform-specific LIMIT clause
 	 *
-	 * @access	public
 	 * @param	string	the sql query string
-	 * @param	integer	the number of rows to limit the query to
-	 * @param	integer	the offset value
+	 * @param	int	the number of rows to limit the query to
+	 * @param	int	the offset value
 	 * @return	string
 	 */
-	function _limit($sql, $limit, $offset)
+	protected function _limit($sql, $limit, $offset)
 	{
 		if ($offset == 0)
 		{
@@ -751,17 +721,15 @@
 	/**
 	 * Close DB Connection
 	 *
-	 * @access	public
 	 * @param	resource
 	 * @return	void
 	 */
-	function _close($conn_id)
+	protected function _close($conn_id)
 	{
 		@cubrid_close($conn_id);
 	}
 
 }
 
-
 /* End of file cubrid_driver.php */
 /* Location: ./system/database/drivers/cubrid/cubrid_driver.php */
diff --git a/system/database/drivers/cubrid/cubrid_forge.php b/system/database/drivers/cubrid/cubrid_forge.php
index 7d606ea..bbda484 100644
--- a/system/database/drivers/cubrid/cubrid_forge.php
+++ b/system/database/drivers/cubrid/cubrid_forge.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * CUBRID Forge Class
  *
@@ -39,11 +37,10 @@
 	/**
 	 * Create database
 	 *
-	 * @access	private
 	 * @param	string	the database name
 	 * @return	bool
 	 */
-	function _create_database($name)
+	public function _create_database($name)
 	{
 		// CUBRID does not allow to create a database in SQL. The GUI tools
 		// have to be used for this purpose.
@@ -55,11 +52,10 @@
 	/**
 	 * Drop database
 	 *
-	 * @access	private
 	 * @param	string	the database name
 	 * @return	bool
 	 */
-	function _drop_database($name)
+	public function _drop_database($name)
 	{
 		// CUBRID does not allow to drop a database in SQL. The GUI tools
 		// have to be used for this purpose.
@@ -71,16 +67,15 @@
 	/**
 	 * Process Fields
 	 *
-	 * @access	private
 	 * @param	mixed	the fields
 	 * @return	string
 	 */
-	function _process_fields($fields)
+	protected function _process_fields($fields)
 	{
 		$current_field_count = 0;
 		$sql = '';
 
-		foreach ($fields as $field=>$attributes)
+		foreach ($fields as $field => $attributes)
 		{
 			// Numeric field names aren't allowed in databases, so if the key is
 			// numeric, we know it was assigned by PHP and the developer manually
@@ -172,15 +167,14 @@
 	/**
 	 * Create Table
 	 *
-	 * @access	private
 	 * @param	string	the table name
 	 * @param	mixed	the fields
 	 * @param	mixed	primary key(s)
 	 * @param	mixed	key(s)
-	 * @param	boolean	should 'IF NOT EXISTS' be added to the SQL
+	 * @param	bool	should 'IF NOT EXISTS' be added to the SQL
 	 * @return	bool
 	 */
-	function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists)
+	public function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists)
 	{
 		$sql = 'CREATE TABLE ';
 
@@ -232,10 +226,9 @@
 	/**
 	 * Drop Table
 	 *
-	 * @access	private
 	 * @return	string
 	 */
-	function _drop_table($table)
+	public function _drop_table($table)
 	{
 		return "DROP TABLE IF EXISTS ".$this->db->_escape_identifiers($table);
 	}
@@ -248,14 +241,13 @@
 	 * Generates a platform-specific query so that a table can be altered
 	 * Called by add_column(), drop_column(), and column_alter(),
 	 *
-	 * @access	private
 	 * @param	string	the ALTER type (ADD, DROP, CHANGE)
 	 * @param	string	the column name
 	 * @param	array	fields
 	 * @param	string	the field after which we should add the new field
-	 * @return	object
+	 * @return	string
 	 */
-	function _alter_table($alter_type, $table, $fields, $after_field = '')
+	public function _alter_table($alter_type, $table, $fields, $after_field = '')
 	{
 		$sql = 'ALTER TABLE '.$this->db->protect_identifiers($table).' '.$alter_type.' ';
 
@@ -282,12 +274,11 @@
 	 *
 	 * Generates a platform-specific query so that a table can be renamed
 	 *
-	 * @access	private
 	 * @param	string	the old table name
 	 * @param	string	the new table name
 	 * @return	string
 	 */
-	function _rename_table($table_name, $new_table_name)
+	public function _rename_table($table_name, $new_table_name)
 	{
 		return 'RENAME TABLE '.$this->db->protect_identifiers($table_name).' AS '.$this->db->protect_identifiers($new_table_name);
 	}
@@ -295,4 +286,4 @@
 }
 
 /* End of file cubrid_forge.php */
-/* Location: ./system/database/drivers/cubrid/cubrid_forge.php */
+/* Location: ./system/database/drivers/cubrid/cubrid_forge.php */
\ No newline at end of file
diff --git a/system/database/drivers/cubrid/cubrid_result.php b/system/database/drivers/cubrid/cubrid_result.php
index a7eeb8a..6a61a21 100644
--- a/system/database/drivers/cubrid/cubrid_result.php
+++ b/system/database/drivers/cubrid/cubrid_result.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// --------------------------------------------------------------------
-
 /**
  * CUBRID Result Class
  *
@@ -41,10 +39,9 @@
 	/**
 	 * Number of rows in the result set
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	int
 	 */
-	function num_rows()
+	public function num_rows()
 	{
 		return @cubrid_num_rows($this->result_id);
 	}
@@ -54,10 +51,9 @@
 	/**
 	 * Number of fields in the result set
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	int
 	 */
-	function num_fields()
+	public function num_fields()
 	{
 		return @cubrid_num_fields($this->result_id);
 	}
@@ -69,10 +65,9 @@
 	 *
 	 * Generates an array of column names
 	 *
-	 * @access	public
 	 * @return	array
 	 */
-	function list_fields()
+	public function list_fields()
 	{
 		return cubrid_column_names($this->result_id);
 	}
@@ -84,10 +79,9 @@
 	 *
 	 * Generates an array of objects containing field meta-data
 	 *
-	 * @access	public
 	 * @return	array
 	 */
-	function field_data()
+	public function field_data()
 	{
 		$retval = array();
 
@@ -147,9 +141,9 @@
 	/**
 	 * Free the result
 	 *
-	 * @return	null
+	 * @return	void
 	 */
-	function free_result()
+	public function free_result()
 	{
 		if(is_resource($this->result_id) ||
 			get_resource_type($this->result_id) == "Unknown" &&
@@ -169,10 +163,9 @@
 	 * this internally before fetching results to make sure the
 	 * result set starts at zero
 	 *
-	 * @access	private
 	 * @return	array
 	 */
-	function _data_seek($n = 0)
+	protected function _data_seek($n = 0)
 	{
 		return cubrid_data_seek($this->result_id, $n);
 	}
@@ -184,10 +177,9 @@
 	 *
 	 * Returns the result set as an array
 	 *
-	 * @access	private
 	 * @return	array
 	 */
-	function _fetch_assoc()
+	protected function _fetch_assoc()
 	{
 		return cubrid_fetch_assoc($this->result_id);
 	}
@@ -199,16 +191,14 @@
 	 *
 	 * Returns the result set as an object
 	 *
-	 * @access	private
 	 * @return	object
 	 */
-	function _fetch_object()
+	protected function _fetch_object()
 	{
 		return cubrid_fetch_object($this->result_id);
 	}
 
 }
 
-
 /* End of file cubrid_result.php */
 /* Location: ./system/database/drivers/cubrid/cubrid_result.php */
\ No newline at end of file
diff --git a/system/database/drivers/cubrid/cubrid_utility.php b/system/database/drivers/cubrid/cubrid_utility.php
index a13c0a5..dafd661 100644
--- a/system/database/drivers/cubrid/cubrid_utility.php
+++ b/system/database/drivers/cubrid/cubrid_utility.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * CUBRID Utility Class
  *
@@ -39,10 +37,9 @@
 	/**
 	 * List databases
 	 *
-	 * @access	private
 	 * @return	array
 	 */
-	function _list_databases()
+	public function _list_databases()
 	{
 		// CUBRID does not allow to see the list of all databases on the
 		// server. It is the way its architecture is designed. Every
@@ -66,12 +63,11 @@
 	 *
 	 * Generates a platform-specific query so that a table can be optimized
 	 *
-	 * @access	private
 	 * @param	string	the table name
-	 * @return	object
+	 * @return	bool
 	 * @link 	http://www.cubrid.org/manual/840/en/Optimize%20Database
 	 */
-	function _optimize_table($table)
+	public function _optimize_table($table)
 	{
 		// No SQL based support in CUBRID as of version 8.4.0. Database or
 		// table optimization can be performed using CUBRID Manager
@@ -86,12 +82,11 @@
 	 *
 	 * Generates a platform-specific query so that a table can be repaired
 	 *
-	 * @access	private
 	 * @param	string	the table name
-	 * @return	object
+	 * @return	bool
 	 * @link 	http://www.cubrid.org/manual/840/en/Checking%20Database%20Consistency
 	 */
-	function _repair_table($table)
+	public function _repair_table($table)
 	{
 		// Not supported in CUBRID as of version 8.4.0. Database or
 		// table consistency can be checked using CUBRID Manager
@@ -103,11 +98,10 @@
 	/**
 	 * CUBRID Export
 	 *
-	 * @access	private
 	 * @param	array	Preferences
 	 * @return	mixed
 	 */
-	function _backup($params = array())
+	public function _backup($params = array())
 	{
 		// No SQL based support in CUBRID as of version 8.4.0. Database or
 		// table backup can be performed using CUBRID Manager
diff --git a/system/database/drivers/mysql/mysql_forge.php b/system/database/drivers/mysql/mysql_forge.php
index 004a5a1..d317ac3 100644
--- a/system/database/drivers/mysql/mysql_forge.php
+++ b/system/database/drivers/mysql/mysql_forge.php
@@ -66,7 +66,7 @@
 	 * @param	mixed	the fields
 	 * @return	string
 	 */
-	private function _process_fields($fields)
+	protected function _process_fields($fields)
 	{
 		$current_field_count = 0;
 		$sql = '';
diff --git a/system/database/drivers/mysqli/mysqli_forge.php b/system/database/drivers/mysqli/mysqli_forge.php
index 9cb1a0c..9ec4bf7 100644
--- a/system/database/drivers/mysqli/mysqli_forge.php
+++ b/system/database/drivers/mysqli/mysqli_forge.php
@@ -66,7 +66,7 @@
 	 * @param	mixed	the fields
 	 * @return	string
 	 */
-	public function _process_fields($fields)
+	protected function _process_fields($fields)
 	{
 		$current_field_count = 0;
 		$sql = '';
diff --git a/system/database/drivers/odbc/odbc_driver.php b/system/database/drivers/odbc/odbc_driver.php
index acc2838..cfa561c 100644
--- a/system/database/drivers/odbc/odbc_driver.php
+++ b/system/database/drivers/odbc/odbc_driver.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * ODBC Database Adapter Class
  *
@@ -42,25 +40,25 @@
  */
 class CI_DB_odbc_driver extends CI_DB {
 
-	var $dbdriver = 'odbc';
+	public $dbdriver = 'odbc';
 
 	// the character used to excape - not necessary for ODBC
-	var $_escape_char = '';
+	protected $_escape_char = '';
 
 	// clause and character used for LIKE escape sequences
-	var $_like_escape_str = " {escape '%s'} ";
-	var $_like_escape_chr = '!';
+	protected $_like_escape_str = " {escape '%s'} ";
+	protected $_like_escape_chr = '!';
 
 	/**
 	 * The syntax to count rows is slightly different across different
 	 * database engines, so this string appears in each driver and is
 	 * used for the count_all() and count_all_results() functions.
 	 */
-	var $_count_string = "SELECT COUNT(*) AS ";
-	var $_random_keyword;
+	protected $_count_string = 'SELECT COUNT(*) AS ';
+	protected $_random_keyword;
 
 
-	function __construct($params)
+	public function __construct($params)
 	{
 		parent::__construct($params);
 
@@ -70,10 +68,9 @@
 	/**
 	 * Non-persistent database connection
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_connect()
+	public function db_connect()
 	{
 		return @odbc_connect($this->hostname, $this->username, $this->password);
 	}
@@ -83,10 +80,9 @@
 	/**
 	 * Persistent database connection
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_pconnect()
+	public function db_pconnect()
 	{
 		return @odbc_pconnect($this->hostname, $this->username, $this->password);
 	}
@@ -99,10 +95,9 @@
 	 * Keep / reestablish the db connection if no queries have been
 	 * sent for a length of time exceeding the server's idle timeout
 	 *
-	 * @access	public
 	 * @return	void
 	 */
-	function reconnect()
+	public function reconnect()
 	{
 		// not implemented in odbc
 	}
@@ -112,10 +107,9 @@
 	/**
 	 * Select the database
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_select()
+	public function db_select()
 	{
 		// Not needed for ODBC
 		return TRUE;
@@ -126,11 +120,10 @@
 	/**
 	 * Execute the query
 	 *
-	 * @access	private called by the base class
 	 * @param	string	an SQL query
 	 * @return	resource
 	 */
-	function _execute($sql)
+	protected function _execute($sql)
 	{
 		$sql = $this->_prep_query($sql);
 		return @odbc_exec($this->conn_id, $sql);
@@ -143,11 +136,10 @@
 	 *
 	 * If needed, each database adapter can prep the query string
 	 *
-	 * @access	private called by execute()
 	 * @param	string	an SQL query
 	 * @return	string
 	 */
-	function _prep_query($sql)
+	protected function _prep_query($sql)
 	{
 		return $sql;
 	}
@@ -157,10 +149,9 @@
 	/**
 	 * Begin Transaction
 	 *
-	 * @access	public
 	 * @return	bool
 	 */
-	function trans_begin($test_mode = FALSE)
+	public function trans_begin($test_mode = FALSE)
 	{
 		if ( ! $this->trans_enabled)
 		{
@@ -186,10 +177,9 @@
 	/**
 	 * Commit Transaction
 	 *
-	 * @access	public
 	 * @return	bool
 	 */
-	function trans_commit()
+	public function trans_commit()
 	{
 		if ( ! $this->trans_enabled)
 		{
@@ -212,10 +202,9 @@
 	/**
 	 * Rollback Transaction
 	 *
-	 * @access	public
 	 * @return	bool
 	 */
-	function trans_rollback()
+	public function trans_rollback()
 	{
 		if ( ! $this->trans_enabled)
 		{
@@ -238,12 +227,11 @@
 	/**
 	 * Escape String
 	 *
-	 * @access	public
 	 * @param	string
 	 * @param	bool	whether or not the string will be used in a LIKE condition
 	 * @return	string
 	 */
-	function escape_str($str, $like = FALSE)
+	public function escape_str($str, $like = FALSE)
 	{
 		if (is_array($str))
 		{
@@ -261,9 +249,9 @@
 		// escape LIKE condition wildcards
 		if ($like === TRUE)
 		{
-			$str = str_replace(	array('%', '_', $this->_like_escape_chr),
-								array($this->_like_escape_chr.'%', $this->_like_escape_chr.'_', $this->_like_escape_chr.$this->_like_escape_chr),
-								$str);
+			return str_replace(array($this->_like_escape_chr, '%', '_'),
+						array($this->_like_escape_chr.$this->_like_escape_chr, $this->_like_escape_chr.'%', $this->_like_escape_chr.'_'),
+						$str);
 		}
 
 		return $str;
@@ -274,10 +262,9 @@
 	/**
 	 * Affected Rows
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	int
 	 */
-	function affected_rows()
+	public function affected_rows()
 	{
 		return @odbc_num_rows($this->conn_id);
 	}
@@ -302,11 +289,10 @@
 	 * Generates a platform-specific query string that counts all records in
 	 * the specified database
 	 *
-	 * @access	public
 	 * @param	string
 	 * @return	string
 	 */
-	function count_all($table = '')
+	public function count_all($table = '')
 	{
 		if ($table == '')
 		{
@@ -332,11 +318,10 @@
 	 *
 	 * Generates a platform-specific query string so that the table names can be fetched
 	 *
-	 * @access	private
-	 * @param	boolean
+	 * @param	bool
 	 * @return	string
 	 */
-	function _list_tables($prefix_limit = FALSE)
+	protected function _list_tables($prefix_limit = FALSE)
 	{
 		$sql = "SHOW TABLES FROM `".$this->database."`";
 
@@ -356,11 +341,10 @@
 	 *
 	 * Generates a platform-specific query string so that the column names can be fetched
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @return	string
 	 */
-	function _list_columns($table = '')
+	protected function _list_columns($table = '')
 	{
 		return "SHOW COLUMNS FROM ".$table;
 	}
@@ -372,11 +356,10 @@
 	 *
 	 * Generates a platform-specific query so that the column data can be retrieved
 	 *
-	 * @access	public
 	 * @param	string	the table name
-	 * @return	object
+	 * @return	string
 	 */
-	function _field_data($table)
+	protected function _field_data($table)
 	{
 		return "SELECT TOP 1 FROM ".$table;
 	}
@@ -403,11 +386,10 @@
 	 *
 	 * This function escapes column and table names
 	 *
-	 * @access	private
 	 * @param	string
 	 * @return	string
 	 */
-	function _escape_identifiers($item)
+	public function _escape_identifiers($item)
 	{
 		if ($this->_escape_char == '')
 		{
@@ -446,11 +428,10 @@
 	 * This function implicitly groups FROM tables so there is no confusion
 	 * about operator precedence in harmony with SQL standards
 	 *
-	 * @access	public
-	 * @param	type
-	 * @return	type
+	 * @param	array
+	 * @return	string
 	 */
-	function _from_tables($tables)
+	protected function _from_tables($tables)
 	{
 		if ( ! is_array($tables))
 		{
@@ -467,13 +448,12 @@
 	 *
 	 * Generates a platform-specific insert string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the insert keys
 	 * @param	array	the insert values
 	 * @return	string
 	 */
-	function _insert($table, $keys, $values)
+	protected function _insert($table, $keys, $values)
 	{
 		return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")";
 	}
@@ -485,7 +465,6 @@
 	 *
 	 * Generates a platform-specific update string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the update data
 	 * @param	array	the where clause
@@ -493,7 +472,7 @@
 	 * @param	array	the limit clause
 	 * @return	string
 	 */
-	function _update($table, $values, $where, $orderby = array(), $limit = FALSE)
+	protected function _update($table, $values, $where, $orderby = array(), $limit = FALSE)
 	{
 		foreach ($values as $key => $val)
 		{
@@ -523,11 +502,10 @@
 	 * If the database does not support the truncate() command
 	 * This function maps to "DELETE FROM table"
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @return	string
 	 */
-	function _truncate($table)
+	protected function _truncate($table)
 	{
 		return $this->_delete($table);
 	}
@@ -539,13 +517,12 @@
 	 *
 	 * Generates a platform-specific delete string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the where clause
 	 * @param	string	the limit clause
 	 * @return	string
 	 */
-	function _delete($table, $where = array(), $like = array(), $limit = FALSE)
+	protected function _delete($table, $where = array(), $like = array(), $limit = FALSE)
 	{
 		$conditions = '';
 
@@ -573,13 +550,12 @@
 	 *
 	 * Generates a platform-specific LIMIT clause
 	 *
-	 * @access	public
 	 * @param	string	the sql query string
-	 * @param	integer	the number of rows to limit the query to
-	 * @param	integer	the offset value
+	 * @param	int	the number of rows to limit the query to
+	 * @param	int	the offset value
 	 * @return	string
 	 */
-	function _limit($sql, $limit, $offset)
+	protected function _limit($sql, $limit, $offset)
 	{
 		// Does ODBC doesn't use the LIMIT clause?
 		return $sql;
@@ -590,19 +566,15 @@
 	/**
 	 * Close DB Connection
 	 *
-	 * @access	public
 	 * @param	resource
 	 * @return	void
 	 */
-	function _close($conn_id)
+	protected function _close($conn_id)
 	{
 		@odbc_close($conn_id);
 	}
 
-
 }
 
-
-
 /* End of file odbc_driver.php */
 /* Location: ./system/database/drivers/odbc/odbc_driver.php */
diff --git a/system/database/drivers/odbc/odbc_forge.php b/system/database/drivers/odbc/odbc_forge.php
index acc2cad..26a524a 100644
--- a/system/database/drivers/odbc/odbc_forge.php
+++ b/system/database/drivers/odbc/odbc_forge.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * ODBC Forge Class
  *
@@ -39,11 +37,10 @@
 	/**
 	 * Create database
 	 *
-	 * @access	private
 	 * @param	string	the database name
 	 * @return	bool
 	 */
-	function _create_database()
+	public function _create_database()
 	{
 		// ODBC has no "create database" command since it's
 		// designed to connect to an existing database
@@ -59,11 +56,10 @@
 	/**
 	 * Drop database
 	 *
-	 * @access	private
 	 * @param	string	the database name
 	 * @return	bool
 	 */
-	function _drop_database($name)
+	public function _drop_database($name)
 	{
 		// ODBC has no "drop database" command since it's
 		// designed to connect to an existing database
@@ -79,15 +75,14 @@
 	/**
 	 * Create Table
 	 *
-	 * @access	private
 	 * @param	string	the table name
 	 * @param	array	the fields
 	 * @param	mixed	primary key(s)
 	 * @param	mixed	key(s)
-	 * @param	boolean	should 'IF NOT EXISTS' be added to the SQL
+	 * @param	bool	should 'IF NOT EXISTS' be added to the SQL
 	 * @return	bool
 	 */
-	function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists)
+	public function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists)
 	{
 		$sql = 'CREATE TABLE ';
 
@@ -99,7 +94,7 @@
 		$sql .= $this->db->_escape_identifiers($table)." (";
 		$current_field_count = 0;
 
-		foreach ($fields as $field=>$attributes)
+		foreach ($fields as $field => $attributes)
 		{
 			// Numeric field names aren't allowed in databases, so if the key is
 			// numeric, we know it was assigned by PHP and the developer manually
@@ -186,10 +181,9 @@
 	/**
 	 * Drop Table
 	 *
-	 * @access	private
 	 * @return	bool
 	 */
-	function _drop_table($table)
+	public function _drop_table($table)
 	{
 		// Not a supported ODBC feature
 		if ($this->db->db_debug)
@@ -207,17 +201,16 @@
 	 * Generates a platform-specific query so that a table can be altered
 	 * Called by add_column(), drop_column(), and column_alter(),
 	 *
-	 * @access	private
 	 * @param	string	the ALTER type (ADD, DROP, CHANGE)
 	 * @param	string	the column name
 	 * @param	string	the table name
 	 * @param	string	the column definition
 	 * @param	string	the default value
-	 * @param	boolean	should 'NOT NULL' be added
+	 * @param	bool	should 'NOT NULL' be added
 	 * @param	string	the field after which we should add the new field
-	 * @return	object
+	 * @return	string
 	 */
-	function _alter_table($alter_type, $table, $column_name, $column_definition = '', $default_value = '', $null = '', $after_field = '')
+	public function _alter_table($alter_type, $table, $column_name, $column_definition = '', $default_value = '', $null = '', $after_field = '')
 	{
 		$sql = 'ALTER TABLE '.$this->db->protect_identifiers($table).' '.$alter_type.' '.$this->db->protect_identifiers($column_name);
 
@@ -260,12 +253,11 @@
 	 *
 	 * Generates a platform-specific query so that a table can be renamed
 	 *
-	 * @access	private
 	 * @param	string	the old table name
 	 * @param	string	the new table name
 	 * @return	string
 	 */
-	function _rename_table($table_name, $new_table_name)
+	public function _rename_table($table_name, $new_table_name)
 	{
 		return 'ALTER TABLE '.$this->db->protect_identifiers($table_name).' RENAME TO '.$this->db->protect_identifiers($new_table_name);
 	}
diff --git a/system/database/drivers/odbc/odbc_result.php b/system/database/drivers/odbc/odbc_result.php
index d19fa24..f6aee35 100644
--- a/system/database/drivers/odbc/odbc_result.php
+++ b/system/database/drivers/odbc/odbc_result.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * ODBC Result Class
  *
@@ -128,9 +126,9 @@
 	/**
 	 * Free the result
 	 *
-	 * @return	null
+	 * @return	void
 	 */
-	function free_result()
+	public function free_result()
 	{
 		if (is_resource($this->result_id))
 		{
@@ -148,10 +146,9 @@
 	 * this internally before fetching results to make sure the
 	 * result set starts at zero
 	 *
-	 * @access	private
-	 * @return	array
+	 * @return	bool
 	 */
-	function _data_seek($n = 0)
+	protected function _data_seek($n = 0)
 	{
 		return FALSE;
 	}
@@ -163,12 +160,11 @@
 	 *
 	 * Returns the result set as an array
 	 *
-	 * @access	private
 	 * @return	array
 	 */
-	function _fetch_assoc()
+	protected function _fetch_assoc()
 	{
-		if (function_exists('odbc_fetch_object'))
+		if (function_exists('odbc_fetch_array'))
 		{
 			return odbc_fetch_array($this->result_id);
 		}
@@ -185,10 +181,9 @@
 	 *
 	 * Returns the result set as an object
 	 *
-	 * @access	private
 	 * @return	object
 	 */
-	function _fetch_object()
+	protected function _fetch_object()
 	{
 		if (function_exists('odbc_fetch_object'))
 		{
@@ -200,6 +195,7 @@
 		}
 	}
 
+	// --------------------------------------------------------------------
 
 	/**
 	 * Result - object
@@ -207,21 +203,24 @@
 	 * subsititutes the odbc_fetch_object function when
 	 * not available (odbc_fetch_object requires unixODBC)
 	 *
-	 * @access	private
 	 * @return	object
 	 */
-	function _odbc_fetch_object(& $odbc_result) {
+	protected function _odbc_fetch_object(& $odbc_result)
+	{
 		$rs = array();
 		$rs_obj = FALSE;
-		if (odbc_fetch_into($odbc_result, $rs)) {
-			foreach ($rs as $k=>$v) {
-				$field_name= odbc_field_name($odbc_result, $k+1);
+		if (odbc_fetch_into($odbc_result, $rs))
+		{
+			foreach ($rs as $k => $v)
+			{
+				$field_name = odbc_field_name($odbc_result, $k+1);
 				$rs_obj->$field_name = $v;
 			}
 		}
 		return $rs_obj;
 	}
 
+	// --------------------------------------------------------------------
 
 	/**
 	 * Result - array
@@ -229,16 +228,18 @@
 	 * subsititutes the odbc_fetch_array function when
 	 * not available (odbc_fetch_array requires unixODBC)
 	 *
-	 * @access	private
 	 * @return	array
 	 */
-	function _odbc_fetch_array(& $odbc_result) {
+	protected function _odbc_fetch_array(& $odbc_result)
+	{
 		$rs = array();
 		$rs_assoc = FALSE;
-		if (odbc_fetch_into($odbc_result, $rs)) {
-			$rs_assoc=array();
-			foreach ($rs as $k=>$v) {
-				$field_name= odbc_field_name($odbc_result, $k+1);
+		if (odbc_fetch_into($odbc_result, $rs))
+		{
+			$rs_assoc = array();
+			foreach ($rs as $k => $v)
+			{
+				$field_name = odbc_field_name($odbc_result, $k+1);
 				$rs_assoc[$field_name] = $v;
 			}
 		}
diff --git a/system/database/drivers/odbc/odbc_utility.php b/system/database/drivers/odbc/odbc_utility.php
index c146c17..5244f08 100644
--- a/system/database/drivers/odbc/odbc_utility.php
+++ b/system/database/drivers/odbc/odbc_utility.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * ODBC Utility Class
  *
@@ -39,10 +37,9 @@
 	/**
 	 * List databases
 	 *
-	 * @access	private
 	 * @return	bool
 	 */
-	function _list_databases()
+	public function _list_databases()
 	{
 		// Not sure if ODBC lets you list all databases...
 		if ($this->db->db_debug)
@@ -59,11 +56,10 @@
 	 *
 	 * Generates a platform-specific query so that a table can be optimized
 	 *
-	 * @access	private
 	 * @param	string	the table name
-	 * @return	object
+	 * @return	bool
 	 */
-	function _optimize_table($table)
+	public function _optimize_table($table)
 	{
 		// Not a supported ODBC feature
 		if ($this->db->db_debug)
@@ -80,11 +76,10 @@
 	 *
 	 * Generates a platform-specific query so that a table can be repaired
 	 *
-	 * @access	private
 	 * @param	string	the table name
-	 * @return	object
+	 * @return	bool
 	 */
-	function _repair_table($table)
+	public function _repair_table($table)
 	{
 		// Not a supported ODBC feature
 		if ($this->db->db_debug)
@@ -99,11 +94,10 @@
 	/**
 	 * ODBC Export
 	 *
-	 * @access	private
 	 * @param	array	Preferences
 	 * @return	mixed
 	 */
-	function _backup($params = array())
+	public function _backup($params = array())
 	{
 		// Currently unsupported
 		return $this->db->display_error('db_unsuported_feature');
@@ -112,4 +106,4 @@
 }
 
 /* End of file odbc_utility.php */
-/* Location: ./system/database/drivers/odbc/odbc_utility.php */
\ No newline at end of file
+/* Location: ./system/database/drivers/odbc/odbc_utility.php */
diff --git a/system/database/drivers/pdo/pdo_driver.php b/system/database/drivers/pdo/pdo_driver.php
index 0976477..658a3d5 100644
--- a/system/database/drivers/pdo/pdo_driver.php
+++ b/system/database/drivers/pdo/pdo_driver.php
@@ -561,6 +561,11 @@
 			// Analog function to show all tables in postgre
 			$sql = "SELECT * FROM information_schema.tables WHERE table_schema = 'public'";
 		}
+		elseif ($this->pdodriver == 'sqlite')
+		{
+			// Analog function to show all tables in sqlite
+			$sql = "SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'";
+		}
 		else
 		{
 			$sql = "SHOW TABLES FROM `".$this->database."`";
@@ -603,6 +608,22 @@
 	 */
 	function _field_data($table)
 	{
+		if ($this->pdodriver == 'mysql' or $this->pdodriver == 'pgsql')
+		{
+			// Analog function for mysql and postgre
+			return 'SELECT * FROM '.$this->_from_tables($table).' LIMIT 1';
+		}
+		elseif ($this->pdodriver == 'oci')
+		{
+			// Analog function for oci
+			return 'SELECT * FROM '.$this->_from_tables($table).' WHERE ROWNUM <= 1';
+		}
+		elseif ($this->pdodriver == 'sqlite')
+		{
+			// Analog function for sqlite
+			return 'PRAGMA table_info('.$this->_from_tables($table).')';
+		}
+		
 		return 'SELECT TOP 1 FROM '.$this->_from_tables($table);
 	}
 
diff --git a/system/database/drivers/pdo/pdo_result.php b/system/database/drivers/pdo/pdo_result.php
index 309f194..384b753 100644
--- a/system/database/drivers/pdo/pdo_result.php
+++ b/system/database/drivers/pdo/pdo_result.php
@@ -160,9 +160,48 @@
 	
 		try
 		{
-			for($i = 0; $i < $this->num_fields(); $i++)
+			if (strpos($this->result_id->queryString, 'PRAGMA') !== FALSE)
 			{
-				$data[] = $this->result_id->getColumnMeta($i);
+				foreach ($this->result_array() as $field)
+				{
+					preg_match('/([a-zA-Z]+)(\(\d+\))?/', $field['type'], $matches);
+
+					$F		= new stdClass();
+					$F->name	= $field['name'];
+					$F->type	= ( ! empty($matches[1])) ? $matches[1] : NULL;
+					$F->default	= NULL;
+					$F->max_length	= ( ! empty($matches[2])) ? preg_replace('/[^\d]/', '', $matches[2]) : NULL;
+					$F->primary_key = (int) $field['pk'];
+					$F->pdo_type	= NULL;
+					
+					$data[] = $F;
+				}
+			}
+			else
+			{
+				for($i = 0, $max = $this->num_fields(); $i < $max; $i++)
+				{
+					$field = $this->result_id->getColumnMeta($i);
+
+					$F		= new stdClass();
+					$F->name	= $field['name'];
+					$F->type	= $field['native_type'];
+					$F->default	= NULL;
+					$F->pdo_type	= $field['pdo_type'];
+					
+					if ($field['precision'] < 0)
+					{
+						$F->max_length	= NULL;
+						$F->primary_key = 0;
+					}
+					else
+					{
+						$F->max_length	= ($field['len'] > 255) ? 0 : $field['len'];
+						$F->primary_key = (int) ( ! empty($field['flags']) && in_array('primary_key', $field['flags']));
+					}
+
+					$data[] = $F;
+				}
 			}
 			
 			return $data;
diff --git a/system/database/drivers/postgre/postgre_driver.php b/system/database/drivers/postgre/postgre_driver.php
index 5d22af2..8112cf9 100644
--- a/system/database/drivers/postgre/postgre_driver.php
+++ b/system/database/drivers/postgre/postgre_driver.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * Postgre Database Adapter Class
  *
@@ -42,29 +40,28 @@
  */
 class CI_DB_postgre_driver extends CI_DB {
 
-	var $dbdriver = 'postgre';
+	public $dbdriver = 'postgre';
 
-	var $_escape_char = '"';
+	protected $_escape_char = '"';
 
 	// clause and character used for LIKE escape sequences
-	var $_like_escape_str = " ESCAPE '%s' ";
-	var $_like_escape_chr = '!';
+	protected $_like_escape_str = " ESCAPE '%s' ";
+	protected $_like_escape_chr = '!';
 
 	/**
 	 * The syntax to count rows is slightly different across different
 	 * database engines, so this string appears in each driver and is
 	 * used for the count_all() and count_all_results() functions.
 	 */
-	var $_count_string = "SELECT COUNT(*) AS ";
-	var $_random_keyword = ' RANDOM()'; // database specific random keyword
+	protected $_count_string = 'SELECT COUNT(*) AS ';
+	protected $_random_keyword = ' RANDOM()'; // database specific random keyword
 
 	/**
 	 * Connection String
 	 *
-	 * @access	private
 	 * @return	string
 	 */
-	function _connect_string()
+	protected function _connect_string()
 	{
 		$components = array(
 								'hostname'	=> 'host',
@@ -90,10 +87,9 @@
 	/**
 	 * Non-persistent database connection
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_connect()
+	public function db_connect()
 	{
 		return @pg_connect($this->_connect_string());
 	}
@@ -103,10 +99,9 @@
 	/**
 	 * Persistent database connection
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_pconnect()
+	public function db_pconnect()
 	{
 		return @pg_pconnect($this->_connect_string());
 	}
@@ -119,10 +114,9 @@
 	 * Keep / reestablish the db connection if no queries have been
 	 * sent for a length of time exceeding the server's idle timeout
 	 *
-	 * @access	public
 	 * @return	void
 	 */
-	function reconnect()
+	public function reconnect()
 	{
 		if (pg_ping($this->conn_id) === FALSE)
 		{
@@ -135,10 +129,9 @@
 	/**
 	 * Select the database
 	 *
-	 * @access	private called by the base class
 	 * @return	resource
 	 */
-	function db_select()
+	public function db_select()
 	{
 		// Not needed for Postgre so we'll return TRUE
 		return TRUE;
@@ -191,11 +184,10 @@
 	/**
 	 * Execute the query
 	 *
-	 * @access	private called by the base class
 	 * @param	string	an SQL query
 	 * @return	resource
 	 */
-	function _execute($sql)
+	protected function _execute($sql)
 	{
 		$sql = $this->_prep_query($sql);
 		return @pg_query($this->conn_id, $sql);
@@ -208,11 +200,10 @@
 	 *
 	 * If needed, each database adapter can prep the query string
 	 *
-	 * @access	private called by execute()
 	 * @param	string	an SQL query
 	 * @return	string
 	 */
-	function _prep_query($sql)
+	protected function _prep_query($sql)
 	{
 		return $sql;
 	}
@@ -281,12 +272,11 @@
 	/**
 	 * Escape String
 	 *
-	 * @access	public
 	 * @param	string
 	 * @param	bool	whether or not the string will be used in a LIKE condition
 	 * @return	string
 	 */
-	function escape_str($str, $like = FALSE)
+	public function escape_str($str, $like = FALSE)
 	{
 		if (is_array($str))
 		{
@@ -303,9 +293,9 @@
 		// escape LIKE condition wildcards
 		if ($like === TRUE)
 		{
-			$str = str_replace(	array('%', '_', $this->_like_escape_chr),
-								array($this->_like_escape_chr.'%', $this->_like_escape_chr.'_', $this->_like_escape_chr.$this->_like_escape_chr),
-								$str);
+			return str_replace(array($this->_like_escape_chr, '%', '_'),
+						array($this->_like_escape_chr.$this->_like_escape_chr, $this->_like_escape_chr.'%', $this->_like_escape_chr.'_'),
+						$str);
 		}
 
 		return $str;
@@ -316,10 +306,9 @@
 	/**
 	 * Affected Rows
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	int
 	 */
-	function affected_rows()
+	public function affected_rows()
 	{
 		return @pg_affected_rows($this->result_id);
 	}
@@ -329,10 +318,9 @@
 	/**
 	 * Insert ID
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	string
 	 */
-	function insert_id()
+	public function insert_id()
 	{
 		$v = $this->version();
 
@@ -372,11 +360,10 @@
 	 * Generates a platform-specific query string that counts all records in
 	 * the specified database
 	 *
-	 * @access	public
 	 * @param	string
 	 * @return	string
 	 */
-	function count_all($table = '')
+	public function count_all($table = '')
 	{
 		if ($table == '')
 		{
@@ -401,11 +388,10 @@
 	 *
 	 * Generates a platform-specific query string so that the table names can be fetched
 	 *
-	 * @access	private
-	 * @param	boolean
+	 * @param	bool
 	 * @return	string
 	 */
-	function _list_tables($prefix_limit = FALSE)
+	protected function _list_tables($prefix_limit = FALSE)
 	{
 		$sql = "SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'";
 
@@ -424,11 +410,10 @@
 	 *
 	 * Generates a platform-specific query string so that the column names can be fetched
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @return	string
 	 */
-	function _list_columns($table = '')
+	protected function _list_columns($table = '')
 	{
 		return "SELECT column_name FROM information_schema.columns WHERE table_name ='".$table."'";
 	}
@@ -440,11 +425,10 @@
 	 *
 	 * Generates a platform-specific query so that the column data can be retrieved
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @return	object
 	 */
-	function _field_data($table)
+	protected function _field_data($table)
 	{
 		return "SELECT * FROM ".$table." LIMIT 1";
 	}
@@ -471,11 +455,10 @@
 	 *
 	 * This function escapes column and table names
 	 *
-	 * @access	private
 	 * @param	string
 	 * @return	string
 	 */
-	function _escape_identifiers($item)
+	public function _escape_identifiers($item)
 	{
 		if ($this->_escape_char == '')
 		{
@@ -514,11 +497,10 @@
 	 * This function implicitly groups FROM tables so there is no confusion
 	 * about operator precedence in harmony with SQL standards
 	 *
-	 * @access	public
-	 * @param	type
-	 * @return	type
+	 * @param	array
+	 * @return	string
 	 */
-	function _from_tables($tables)
+	protected function _from_tables($tables)
 	{
 		if ( ! is_array($tables))
 		{
@@ -535,13 +517,12 @@
 	 *
 	 * Generates a platform-specific insert string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the insert keys
 	 * @param	array	the insert values
 	 * @return	string
 	 */
-	function _insert($table, $keys, $values)
+	protected function _insert($table, $keys, $values)
 	{
 		return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES (".implode(', ', $values).")";
 	}
@@ -553,13 +534,12 @@
 	 *
 	 * Generates a platform-specific insert string from the supplied data
 	 *
-	 * @access  public
 	 * @param   string  the table name
 	 * @param   array   the insert keys
 	 * @param   array   the insert values
 	 * @return  string
 	 */
-	function _insert_batch($table, $keys, $values)
+	protected function _insert_batch($table, $keys, $values)
 	{
 		return "INSERT INTO ".$table." (".implode(', ', $keys).") VALUES ".implode(', ', $values);
 	}
@@ -571,7 +551,6 @@
 	 *
 	 * Generates a platform-specific update string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the update data
 	 * @param	array	the where clause
@@ -579,7 +558,7 @@
 	 * @param	array	the limit clause
 	 * @return	string
 	 */
-	function _update($table, $values, $where, $orderby = array(), $limit = FALSE)
+	protected function _update($table, $values, $where, $orderby = array(), $limit = FALSE)
 	{
 		foreach ($values as $key => $val)
 		{
@@ -602,11 +581,10 @@
 	 * If the database does not support the truncate() command
 	 * This function maps to "DELETE FROM table"
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @return	string
 	 */
-	function _truncate($table)
+	protected function _truncate($table)
 	{
 		return "TRUNCATE ".$table;
 	}
@@ -618,13 +596,12 @@
 	 *
 	 * Generates a platform-specific delete string from the supplied data
 	 *
-	 * @access	public
 	 * @param	string	the table name
 	 * @param	array	the where clause
 	 * @param	string	the limit clause
 	 * @return	string
 	 */
-	function _delete($table, $where = array(), $like = array(), $limit = FALSE)
+	protected function _delete($table, $where = array(), $like = array(), $limit = FALSE)
 	{
 		$conditions = '';
 
@@ -649,13 +626,12 @@
 	 *
 	 * Generates a platform-specific LIMIT clause
 	 *
-	 * @access	public
 	 * @param	string	the sql query string
-	 * @param	integer	the number of rows to limit the query to
-	 * @param	integer	the offset value
+	 * @param	int	the number of rows to limit the query to
+	 * @param	int	the offset value
 	 * @return	string
 	 */
-	function _limit($sql, $limit, $offset)
+	protected function _limit($sql, $limit, $offset)
 	{
 		$sql .= "LIMIT ".$limit;
 
@@ -672,18 +648,15 @@
 	/**
 	 * Close DB Connection
 	 *
-	 * @access	public
 	 * @param	resource
 	 * @return	void
 	 */
-	function _close($conn_id)
+	protected function _close($conn_id)
 	{
 		@pg_close($conn_id);
 	}
 
-
 }
 
-
 /* End of file postgre_driver.php */
 /* Location: ./system/database/drivers/postgre/postgre_driver.php */
diff --git a/system/database/drivers/postgre/postgre_forge.php b/system/database/drivers/postgre/postgre_forge.php
index 5771005..2a8fdd6 100644
--- a/system/database/drivers/postgre/postgre_forge.php
+++ b/system/database/drivers/postgre/postgre_forge.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * Postgre Forge Class
  *
@@ -39,11 +37,10 @@
 	/**
 	 * Create database
 	 *
-	 * @access	private
 	 * @param	string	the database name
 	 * @return	bool
 	 */
-	function _create_database($name)
+	public function _create_database($name)
 	{
 		return "CREATE DATABASE ".$name;
 	}
@@ -53,29 +50,28 @@
 	/**
 	 * Drop database
 	 *
-	 * @access	private
 	 * @param	string	the database name
 	 * @return	bool
 	 */
-	function _drop_database($name)
+	public function _drop_database($name)
 	{
 		return "DROP DATABASE ".$name;
 	}
 
 	// --------------------------------------------------------------------
-	
+
 	/**
 	 * Process Fields
 	 *
 	 * @param	mixed	the fields
 	 * @return	string
 	 */
-	function _process_fields($fields, $primary_keys=array())
+	protected function _process_fields($fields, $primary_keys=array())
 	{
 		$sql = '';
 		$current_field_count = 0;
 
-		foreach ($fields as $field=>$attributes)
+		foreach ($fields as $field => $attributes)
 		{
 			// Numeric field names aren't allowed in databases, so if the key is
 			// numeric, we know it was assigned by PHP and the developer manually
@@ -168,7 +164,7 @@
 				$sql .= ',';
 			}
 		}
-		
+
 		return $sql;
 	}
 
@@ -177,15 +173,14 @@
 	/**
 	 * Create Table
 	 *
-	 * @access	private
 	 * @param	string	the table name
 	 * @param	array	the fields
 	 * @param	mixed	primary key(s)
 	 * @param	mixed	key(s)
-	 * @param	boolean	should 'IF NOT EXISTS' be added to the SQL
+	 * @param	bool	should 'IF NOT EXISTS' be added to the SQL
 	 * @return	bool
 	 */
-	function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists)
+	public function _create_table($table, $fields, $primary_keys, $keys, $if_not_exists)
 	{
 		$sql = 'CREATE TABLE ';
 
@@ -241,8 +236,10 @@
 
 	/**
 	 * Drop Table
+	 *
+	 * @return	string
 	 */
-	function _drop_table($table)
+	public function _drop_table($table)
 	{
 		return "DROP TABLE IF EXISTS ".$this->db->_escape_identifiers($table)." CASCADE";
 	}
@@ -255,7 +252,6 @@
 	 * Generates a platform-specific query so that a table can be altered
 	 * Called by add_column(), drop_column(), and column_alter(),
 	 *
-	 * @access	private
 	 * @param	string	the ALTER type (ADD, DROP, CHANGE)
 	 * @param	string	the column name
 	 * @param	string	the table name
@@ -263,9 +259,9 @@
 	 * @param	string	the default value
 	 * @param	boolean	should 'NOT NULL' be added
 	 * @param	string	the field after which we should add the new field
-	 * @return	object
+	 * @return	string
 	 */
- 	function _alter_table($alter_type, $table, $fields, $after_field = '')
+	public function _alter_table($alter_type, $table, $fields, $after_field = '')
  	{
  		$sql = 'ALTER TABLE '.$this->db->protect_identifiers($table).' '.$alter_type.' ';
 
@@ -292,12 +288,11 @@
 	 *
 	 * Generates a platform-specific query so that a table can be renamed
 	 *
-	 * @access	private
 	 * @param	string	the old table name
 	 * @param	string	the new table name
 	 * @return	string
 	 */
-	function _rename_table($table_name, $new_table_name)
+	public function _rename_table($table_name, $new_table_name)
 	{
 		return 'ALTER TABLE '.$this->db->protect_identifiers($table_name).' RENAME TO '.$this->db->protect_identifiers($new_table_name);
 	}
diff --git a/system/database/drivers/postgre/postgre_result.php b/system/database/drivers/postgre/postgre_result.php
index 12d7547..b3eafb8 100644
--- a/system/database/drivers/postgre/postgre_result.php
+++ b/system/database/drivers/postgre/postgre_result.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * Postgres Result Class
  *
@@ -41,10 +39,9 @@
 	/**
 	 * Number of rows in the result set
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	int
 	 */
-	function num_rows()
+	public function num_rows()
 	{
 		return @pg_num_rows($this->result_id);
 	}
@@ -54,10 +51,9 @@
 	/**
 	 * Number of fields in the result set
 	 *
-	 * @access	public
-	 * @return	integer
+	 * @return	int
 	 */
-	function num_fields()
+	public function num_fields()
 	{
 		return @pg_num_fields($this->result_id);
 	}
@@ -69,10 +65,9 @@
 	 *
 	 * Generates an array of column names
 	 *
-	 * @access	public
 	 * @return	array
 	 */
-	function list_fields()
+	public function list_fields()
 	{
 		$field_names = array();
 		for ($i = 0; $i < $this->num_fields(); $i++)
@@ -90,10 +85,9 @@
 	 *
 	 * Generates an array of objects containing field meta-data
 	 *
-	 * @access	public
 	 * @return	array
 	 */
-	function field_data()
+	public function field_data()
 	{
 		$retval = array();
 		for ($i = 0; $i < $this->num_fields(); $i++)
@@ -116,9 +110,9 @@
 	/**
 	 * Free the result
 	 *
-	 * @return	null
+	 * @return	void
 	 */
-	function free_result()
+	public function free_result()
 	{
 		if (is_resource($this->result_id))
 		{
@@ -132,14 +126,13 @@
 	/**
 	 * Data Seek
 	 *
-	 * Moves the internal pointer to the desired offset.  We call
+	 * Moves the internal pointer to the desired offset. We call
 	 * this internally before fetching results to make sure the
 	 * result set starts at zero
 	 *
-	 * @access	private
 	 * @return	array
 	 */
-	function _data_seek($n = 0)
+	protected function _data_seek($n = 0)
 	{
 		return pg_result_seek($this->result_id, $n);
 	}
@@ -151,10 +144,9 @@
 	 *
 	 * Returns the result set as an array
 	 *
-	 * @access	private
 	 * @return	array
 	 */
-	function _fetch_assoc()
+	protected function _fetch_assoc()
 	{
 		return pg_fetch_assoc($this->result_id);
 	}
@@ -166,16 +158,14 @@
 	 *
 	 * Returns the result set as an object
 	 *
-	 * @access	private
 	 * @return	object
 	 */
-	function _fetch_object()
+	protected function _fetch_object()
 	{
 		return pg_fetch_object($this->result_id);
 	}
 
 }
 
-
 /* End of file postgre_result.php */
-/* Location: ./system/database/drivers/postgre/postgre_result.php */
\ No newline at end of file
+/* Location: ./system/database/drivers/postgre/postgre_result.php */
diff --git a/system/helpers/cookie_helper.php b/system/helpers/cookie_helper.php
index 38a2f78..ec8aa32 100644
--- a/system/helpers/cookie_helper.php
+++ b/system/helpers/cookie_helper.php
@@ -40,7 +40,7 @@
 /**
  * Set cookie
  *
- * Accepts six parameter, or you can submit an associative
+ * Accepts seven parameters, or you can submit an associative
  * array in the first parameter containing all the values.
  *
  * @param	mixed
@@ -49,15 +49,17 @@
  * @param	string	the cookie domain.  Usually:  .yourdomain.com
  * @param	string	the cookie path
  * @param	string	the cookie prefix
+ * @param	bool	true makes the cookie secure
+ * @param	bool	true makes the cookie accessible via http(s) only (no javascript)
  * @return	void
  */
 if ( ! function_exists('set_cookie'))
 {
-	function set_cookie($name = '', $value = '', $expire = '', $domain = '', $path = '/', $prefix = '', $secure = FALSE)
+	function set_cookie($name = '', $value = '', $expire = '', $domain = '', $path = '/', $prefix = '', $secure = FALSE, $httponly = FALSE)
 	{
 		// Set the config file options
 		$CI =& get_instance();
-		$CI->input->set_cookie($name, $value, $expire, $domain, $path, $prefix, $secure);
+		$CI->input->set_cookie($name, $value, $expire, $domain, $path, $prefix, $secure, $httponly);
 	}
 }
 
diff --git a/system/helpers/date_helper.php b/system/helpers/date_helper.php
index 2a34cf9..d545532 100644
--- a/system/helpers/date_helper.php
+++ b/system/helpers/date_helper.php
@@ -128,15 +128,16 @@
 	function standard_date($fmt = 'DATE_RFC822', $time = '')
 	{
 		$formats = array(
-						'DATE_ATOM'		=>	'%Y-%m-%dT%H:%i:%s%Q',
+						'DATE_ATOM'		=>	'%Y-%m-%dT%H:%i:%s%O',
 						'DATE_COOKIE'	=>	'%l, %d-%M-%y %H:%i:%s UTC',
-						'DATE_ISO8601'	=>	'%Y-%m-%dT%H:%i:%s%Q',
+						'DATE_ISO8601'	=>	'%Y-%m-%dT%H:%i:%s%O',
 						'DATE_RFC822'	=>	'%D, %d %M %y %H:%i:%s %O',
 						'DATE_RFC850'	=>	'%l, %d-%M-%y %H:%i:%s UTC',
 						'DATE_RFC1036'	=>	'%D, %d %M %y %H:%i:%s %O',
 						'DATE_RFC1123'	=>	'%D, %d %M %Y %H:%i:%s %O',
+						'DATE_RFC2822'	=>	'%D, %d %M %Y %H:%i:%s %O',
 						'DATE_RSS'		=>	'%D, %d %M %Y %H:%i:%s %O',
-						'DATE_W3C'		=>	'%Y-%m-%dT%H:%i:%s%Q'
+						'DATE_W3C'		=>	'%Y-%m-%dT%H:%i:%s%O'
 						);
 
 		if ( ! isset($formats[$fmt]))
@@ -159,11 +160,12 @@
  * @access	public
  * @param	integer	a number of seconds
  * @param	integer	Unix timestamp
- * @return	integer
+ * @param	integer	a number of display units
+ * @return	string
  */
 if ( ! function_exists('timespan'))
 {
-	function timespan($seconds = 1, $time = '')
+	function timespan($seconds = 1, $time = '', $units = 7)
 	{
 		$CI =& get_instance();
 		$CI->lang->load('date');
@@ -178,24 +180,29 @@
 			$time = time();
 		}
 
+		if ( ! is_numeric($units))
+		{
+			$units = 7;
+		}
+
 		$seconds = ($time <= $seconds) ? 1 : $time - $seconds;
 
-		$str = '';
+		$str = array();
 		$years = floor($seconds / 31557600);
 
 		if ($years > 0)
 		{
-			$str .= $years.' '.$CI->lang->line((($years	> 1) ? 'date_years' : 'date_year')).', ';
+			$str[] = $years.' '.$CI->lang->line((($years	> 1) ? 'date_years' : 'date_year'));
 		}
 
 		$seconds -= $years * 31557600;
 		$months = floor($seconds / 2629743);
 
-		if ($years > 0 OR $months > 0)
+		if (count($str) < $units && ($years > 0 OR $months > 0))
 		{
 			if ($months > 0)
 			{
-				$str .= $months.' '.$CI->lang->line((($months	> 1) ? 'date_months' : 'date_month')).', ';
+				$str[] = $months.' '.$CI->lang->line((($months	> 1) ? 'date_months' : 'date_month'));
 			}
 
 			$seconds -= $months * 2629743;
@@ -203,11 +210,11 @@
 
 		$weeks = floor($seconds / 604800);
 
-		if ($years > 0 OR $months > 0 OR $weeks > 0)
+		if (count($str) < $units && ($years > 0 OR $months > 0 OR $weeks > 0))
 		{
 			if ($weeks > 0)
 			{
-				$str .= $weeks.' '.$CI->lang->line((($weeks	> 1) ? 'date_weeks' : 'date_week')).', ';
+				$str[] = $weeks.' '.$CI->lang->line((($weeks	> 1) ? 'date_weeks' : 'date_week'));
 			}
 
 			$seconds -= $weeks * 604800;
@@ -215,11 +222,11 @@
 
 		$days = floor($seconds / 86400);
 
-		if ($months > 0 OR $weeks > 0 OR $days > 0)
+		if (count($str) < $units && ($months > 0 OR $weeks > 0 OR $days > 0))
 		{
 			if ($days > 0)
 			{
-				$str .= $days.' '.$CI->lang->line((($days	> 1) ? 'date_days' : 'date_day')).', ';
+				$str[] = $days.' '.$CI->lang->line((($days	> 1) ? 'date_days' : 'date_day'));
 			}
 
 			$seconds -= $days * 86400;
@@ -227,11 +234,11 @@
 
 		$hours = floor($seconds / 3600);
 
-		if ($days > 0 OR $hours > 0)
+		if (count($str) < $units && ($days > 0 OR $hours > 0))
 		{
 			if ($hours > 0)
 			{
-				$str .= $hours.' '.$CI->lang->line((($hours	> 1) ? 'date_hours' : 'date_hour')).', ';
+				$str[] = $hours.' '.$CI->lang->line((($hours	> 1) ? 'date_hours' : 'date_hour'));
 			}
 
 			$seconds -= $hours * 3600;
@@ -239,22 +246,22 @@
 
 		$minutes = floor($seconds / 60);
 
-		if ($days > 0 OR $hours > 0 OR $minutes > 0)
+		if (count($str) < $units && ($days > 0 OR $hours > 0 OR $minutes > 0))
 		{
 			if ($minutes > 0)
 			{
-				$str .= $minutes.' '.$CI->lang->line((($minutes	> 1) ? 'date_minutes' : 'date_minute')).', ';
+				$str[] = $minutes.' '.$CI->lang->line((($minutes	> 1) ? 'date_minutes' : 'date_minute'));
 			}
 
 			$seconds -= $minutes * 60;
 		}
 
-		if ($str == '')
+		if (count($str) === 0)
 		{
-			$str .= $seconds.' '.$CI->lang->line((($seconds	> 1) ? 'date_seconds' : 'date_second')).', ';
+			$str[] = $seconds.' '.$CI->lang->line((($seconds	> 1) ? 'date_seconds' : 'date_second'));
 		}
 
-		return substr(trim($str), 0, -1);
+		return implode(', ', $str);
 	}
 }
 
diff --git a/system/helpers/directory_helper.php b/system/helpers/directory_helper.php
index 1d67e05..d7ca13e 100644
--- a/system/helpers/directory_helper.php
+++ b/system/helpers/directory_helper.php
@@ -1,13 +1,13 @@
-<?php  if ( ! defined('BASEPATH')) exit('No direct script access allowed');
+<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 /**
  * CodeIgniter
  *
  * An open source application development framework for PHP 5.2.4 or newer
  *
  * NOTICE OF LICENSE
- * 
+ *
  * Licensed under the Open Software License version 3.0
- * 
+ *
  * This source file is subject to the Open Software License (OSL 3.0) that is
  * bundled with this package in the files license.txt / license.rst.  It is
  * also available through the world wide web at this URL:
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * CodeIgniter Directory Helpers
  *
@@ -43,12 +41,11 @@
  * Create a Directory Map
  *
  * Reads the specified directory and builds an array
- * representation of it.  Sub-folders contained with the
+ * representation of it. Sub-folders contained with the
  * directory will be mapped as well.
  *
- * @access	public
  * @param	string	path to source
- * @param	int		depth of directories to traverse (0 = fully recursive, 1 = current dir, etc)
+ * @param	int	depth of directories to traverse (0 = fully recursive, 1 = current dir, etc)
  * @return	array
  */
 if ( ! function_exists('directory_map'))
@@ -64,7 +61,7 @@
 			while (FALSE !== ($file = readdir($fp)))
 			{
 				// Remove '.', '..', and hidden files [optional]
-				if ( ! trim($file, '.') OR ($hidden == FALSE && $file[0] == '.'))
+				if ( ! trim($file, '.') OR ($hidden == FALSE && $file[0] === '.'))
 				{
 					continue;
 				}
@@ -87,6 +84,5 @@
 	}
 }
 
-
 /* End of file directory_helper.php */
-/* Location: ./system/helpers/directory_helper.php */
\ No newline at end of file
+/* Location: ./system/helpers/directory_helper.php */
diff --git a/system/helpers/inflector_helper.php b/system/helpers/inflector_helper.php
index 9cf015d..485806b 100644
--- a/system/helpers/inflector_helper.php
+++ b/system/helpers/inflector_helper.php
@@ -170,7 +170,7 @@
 {
 	function camelize($str)
 	{
-		return str_replace(' ', '', ucwords(preg_replace('/[\s_]+/', ' ', strtolower($str))));
+		return strtolower($str[0]).substr(str_replace(' ', '', ucwords(preg_replace('/[\s_]+/', ' ', $str))), 1);
 	}
 }
 
diff --git a/system/helpers/path_helper.php b/system/helpers/path_helper.php
index 2eb85fe..c31f0bd 100644
--- a/system/helpers/path_helper.php
+++ b/system/helpers/path_helper.php
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * CodeIgniter Path Helpers
  *
@@ -51,28 +49,24 @@
 {
 	function set_realpath($path, $check_existance = FALSE)
 	{
-		// Security check to make sure the path is NOT a URL.  No remote file inclusion!
-		if (preg_match("#^(http:\/\/|https:\/\/|www\.|ftp|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})#i", $path))
+		// Security check to make sure the path is NOT a URL. No remote file inclusion!
+		if (preg_match('#^(http:\/\/|https:\/\/|www\.|ftp|[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3})#i', $path))
 		{
 			show_error('The path you submitted must be a local server path, not a URL');
 		}
 
 		// Resolve the path
-		if (function_exists('realpath') AND @realpath($path) !== FALSE)
+		if (function_exists('realpath') && @realpath($path) !== FALSE)
 		{
 			$path = realpath($path);
 		}
-
-		// Add a trailing slash
-		$path = rtrim($path, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR;
-
-		// Make sure the path exists
-		if ($check_existance == TRUE && ! is_dir($path))
+		elseif ($check_existance && ! is_dir($path) && ! is_file($path))
 		{
 			show_error('Not a valid path: '.$path);
 		}
 
-		return $path;
+		// Add a trailing slash, if this is a directory
+		return is_dir($path) ? rtrim($path, DIRECTORY_SEPARATOR).DIRECTORY_SEPARATOR : $path;
 	}
 }
 
diff --git a/system/helpers/security_helper.php b/system/helpers/security_helper.php
index e05e947..8c7adea 100644
--- a/system/helpers/security_helper.php
+++ b/system/helpers/security_helper.php
@@ -25,8 +25,6 @@
  * @filesource
  */
 
-// ------------------------------------------------------------------------
-
 /**
  * CodeIgniter Security Helpers
  *
@@ -42,7 +40,6 @@
 /**
  * XSS Filtering
  *
- * @access	public
  * @param	string
  * @param	bool	whether or not the content is an image file
  * @return	string
@@ -61,7 +58,6 @@
 /**
  * Sanitize Filename
  *
- * @access	public
  * @param	string
  * @return	string
  */
@@ -79,7 +75,6 @@
 /**
  * Hash encode a string
  *
- * @access	public
  * @param	string
  * @return	string
  */
@@ -87,7 +82,12 @@
 {
 	function do_hash($str, $type = 'sha1')
 	{
-		return ($type === 'sha1') ? sha1($str) : md5($str);
+		if ( ! in_array(strtolower($type), hash_algos()))
+		{
+			$type = 'md5';
+		}
+
+		return hash($type, $str);
 	}
 }
 
@@ -96,7 +96,6 @@
 /**
  * Strip Image Tags
  *
- * @access	public
  * @param	string
  * @return	string
  */
@@ -104,7 +103,7 @@
 {
 	function strip_image_tags($str)
 	{
-		return preg_replace(array("#<img\s+.*?src\s*=\s*[\"'](.+?)[\"'].*?\>#", "#<img\s+.*?src\s*=\s*(.+?).*?\>#"), "\\1", $str);
+		return preg_replace(array('#<img\s+.*?src\s*=\s*["\'](.+?)["\'].*?\>#', '#<img\s+.*?src\s*=\s*(.+?).*?\>#'), '\\1', $str);
 	}
 }
 
@@ -113,7 +112,6 @@
 /**
  * Convert PHP tags to entities
  *
- * @access	public
  * @param	string
  * @return	string
  */
diff --git a/system/language/english/upload_lang.php b/system/language/english/upload_lang.php
index ec5de1e..4fa8394 100644
--- a/system/language/english/upload_lang.php
+++ b/system/language/english/upload_lang.php
@@ -35,7 +35,7 @@
 $lang['upload_no_file_selected'] = "You did not select a file to upload.";
 $lang['upload_invalid_filetype'] = "The filetype you are attempting to upload is not allowed.";
 $lang['upload_invalid_filesize'] = "The file you are attempting to upload is larger than the permitted size.";
-$lang['upload_invalid_dimensions'] = "The image you are attempting to upload exceedes the maximum height or width.";
+$lang['upload_invalid_dimensions'] = "The image you are attempting to upload exceeds the maximum height or width.";
 $lang['upload_destination_error'] = "A problem was encountered while attempting to move the uploaded file to the final destination.";
 $lang['upload_no_filepath'] = "The upload path does not appear to be valid.";
 $lang['upload_no_file_types'] = "You have not specified any allowed file types.";
diff --git a/system/libraries/Form_validation.php b/system/libraries/Form_validation.php
index 9491f35..3e0c72e 100644
--- a/system/libraries/Form_validation.php
+++ b/system/libraries/Form_validation.php
@@ -101,7 +101,7 @@
 			return $this;
 		}
 
-		// If an array was passed via the first parameter instead of indidual string
+		// If an array was passed via the first parameter instead of individual string
 		// values we cycle through it and recursively call this function.
 		if (is_array($field))
 		{
diff --git a/system/libraries/Session.php b/system/libraries/Session.php
index 0b9d45b..3a80c16 100644
--- a/system/libraries/Session.php
+++ b/system/libraries/Session.php
@@ -48,6 +48,7 @@
 	public $cookie_path			= '';
 	public $cookie_domain			= '';
 	public $cookie_secure			= FALSE;
+	public $cookie_httponly 		= FALSE;
 	public $sess_time_to_update		= 300;
 	public $encryption_key			= '';
 	public $flashdata_key			= 'flash';
@@ -72,7 +73,7 @@
 
 		// Set all the session preferences, which can either be set
 		// manually via the $params array above or via the config file
-		foreach (array('sess_encrypt_cookie', 'sess_use_database', 'sess_table_name', 'sess_expiration', 'sess_expire_on_close', 'sess_match_ip', 'sess_match_useragent', 'sess_cookie_name', 'cookie_path', 'cookie_domain', 'cookie_secure', 'sess_time_to_update', 'time_reference', 'cookie_prefix', 'encryption_key') as $key)
+		foreach (array('sess_encrypt_cookie', 'sess_use_database', 'sess_table_name', 'sess_expiration', 'sess_expire_on_close', 'sess_match_ip', 'sess_match_useragent', 'sess_cookie_name', 'cookie_path', 'cookie_domain', 'cookie_secure', 'cookie_httponly', 'sess_time_to_update', 'time_reference', 'cookie_prefix', 'encryption_key') as $key)
 		{
 			$this->$key = (isset($params[$key])) ? $params[$key] : $this->CI->config->item($key);
 		}
@@ -468,6 +469,29 @@
 	{
 		return $this->userdata;
 	}
+	
+	// --------------------------------------------------------------------------
+	
+	/**
+	 * Fetch all flashdata
+	 * 
+	 * @return	array
+	 */
+	public function all_flashdata()
+	{
+		$out = array();
+		
+		// loop through all userdata
+		foreach ($this->all_userdata() as $key => $val)
+		{	
+			// if it contains flashdata, add it
+			if (strpos($key, 'flash:old:') !== FALSE)
+			{
+				$out[$key] = $val;
+			}
+		}
+		return $out;
+	}
 
 	// --------------------------------------------------------------------
 
@@ -666,13 +690,14 @@
 
 		// Set the cookie
 		setcookie(
-				$this->sess_cookie_name,
-				$cookie_data,
-				$expire,
-				$this->cookie_path,
-				$this->cookie_domain,
-				$this->cookie_secure
-			);
+			$this->sess_cookie_name,
+			$cookie_data,
+			$expire,
+			$this->cookie_path,
+			$this->cookie_domain,
+			$this->cookie_secure,
+			$this->cookie_httponly
+		);
 	}
 
 	// --------------------------------------------------------------------
diff --git a/system/libraries/Table.php b/system/libraries/Table.php
index 99d001c..11a4858 100644
--- a/system/libraries/Table.php
+++ b/system/libraries/Table.php
@@ -112,7 +112,7 @@
 	 */
 	public function make_columns($array = array(), $col_limit = 0)
 	{
-		if ( ! is_array($array) OR count($array) === 0)
+		if ( ! is_array($array) OR count($array) === 0 OR ! is_int($col_limit))
 		{
 			return FALSE;
 		}
@@ -405,7 +405,7 @@
 		// First generate the headings from the table column names
 		if (count($this->heading) === 0)
 		{
-			if ( ! method_exists($query, 'list_fields'))
+			if ( ! is_callable(array($query, 'list_fields')))
 			{
 				return FALSE;
 			}
diff --git a/tests/Bootstrap.php b/tests/Bootstrap.php
new file mode 100644
index 0000000..39c24b2
--- /dev/null
+++ b/tests/Bootstrap.php
@@ -0,0 +1,21 @@
+<?php
+
+// Errors on full!
+ini_set('display_errors', 1);
+error_reporting(E_ALL | E_STRICT);
+
+$dir = realpath(dirname(__FILE__));
+
+
+// Path constants
+define('PROJECT_BASE',	realpath($dir.'/../').'/');
+define('BASEPATH',		PROJECT_BASE.'system/');
+define('APPPATH',		PROJECT_BASE.'application/');
+define('VIEWPATH',		PROJECT_BASE.'');
+
+
+// Prep our test environment
+require_once $dir.'/lib/common.php';
+require_once $dir.'/lib/ci_testcase.php';
+
+unset($dir);
\ No newline at end of file
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 0000000..6d83c34
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,164 @@
+# CodeIgniter Unit Tests #
+
+Status : [![Build Status](https://secure.travis-ci.org/EllisLab/CodeIgniter.png?branch=feature/unit-tests)](http://travis-ci.org/EllisLab/CodeIgniter)
+
+*Do not merge to default until these issues have been addressed*
+
+- Clean up naming conventions
+- Figure out config stuff
+- Figure out database testing
+
+### Introduction:
+
+This is the preliminary CodeIgniter testing documentation. It
+will cover both internal as well as external APIs and the reasoning
+behind their implemenation, where appropriate. As with all CodeIgniter
+documentation, this file should maintain a mostly human readable
+format to facilitate clean api design. [see http://arrenbrecht.ch/testing/]
+
+*First public draft: everything is subject to change*
+
+### Requirements
+
+PHP Unit >= 3.5.6
+
+	pear channel-discover pear.phpunit.de
+	pear install phpunit/PHPUnit
+
+vfsStream
+
+	pear channel-discover pear.php-tools.net
+	pear install pat/vfsStream-alpha
+
+#### Installation of PEAR and PHPUnit on Ubuntu
+
+  Installation on Ubuntu requires a few steps. Depending on your setup you may
+  need to use 'sudo' to install these. Mileage may vary but these steps are a
+  good start.
+
+	# Install the PEAR package
+	sudo apt-get install php-pear
+
+	# Add a few sources to PEAR
+	pear channel-discover pear.phpunit.de
+	pear channel-discover pear.symfony-project.com
+	pear channel-discover components.ez.no
+	pear channel-discover pear.php-tools.net 
+
+	# Finally install PHPUnit and vfsStream (including dependencies)
+	pear install --alldeps phpunit/PHPUnit
+	pear install --alldeps pat/vfsStream-alpha
+
+	# Finally, run 'phpunit' from within the ./tests directory
+	# and you should be on your way!
+
+## Test Suites:
+
+CodeIgniter bootstraps a request very directly, with very flat class
+hierarchy. As a result, there is no main CodeIgniter class until the
+controller is instantiated.
+
+This has forced the core classes to be relatively decoupled, which is
+a good thing. However, it makes that portion of code relatively hard
+to test.
+
+Right now that means we'll probably have two core test suites, along
+with a base for application and package tests. That gives us:
+
+1. Bootstrap Test	- test common.php and sanity check codeigniter.php [in planning]
+2. System Test		- test core components in relative isolation [in development]
+3. Application Test	- bootstrapping for application/tests [not started]
+4. Package Test		- bootstrapping for <package>/tests [not started]
+
+### CI_TestCase Documentation
+
+Test cases should extend CI_TestCase. This internally extends
+PHPUnit\_Framework\_TestCase, so you have access to all of your
+usual PHPUnit methods.
+
+We need to provide a simple way to modify the globals and the
+common function output. We also need to be able to mock up
+the super object as we please.
+
+Current API is *not stable*. Names and implementations will change.
+
+    $this->ci_set_config($key, $val)
+
+Set the global config variables. If key is an array, it will
+replace the entire config array. They are _not_ merged.
+
+    $this->ci_instance($obj)
+
+Set the object to use as the "super object", in a lot
+of cases this will be a simple stdClass with the attributes
+you need it to have. If no parameter, will return the instance.
+
+	$this->ci_instance_var($name, $val)
+
+Add an attribute to the super object. This is useful if you
+set up a simple instance in setUp and then need to add different
+class mockups to your super object.
+
+	$this->ci_core_class($name)
+
+Get the _class name_ of a core class, so that you can instantiate
+it. The variable is returned by reference and is tied to the correct
+$GLOBALS key. For example:
+    
+	$cfg =& $this->ci_core_class('cfg'); // returns 'CI_Config'
+    $cfg = new $cfg; // instantiates config and overwrites the CFG global
+
+	$this->ci_set_core_class($name, $obj)
+	
+An alternative way to set one of the core globals.
+
+	$this->ci_get_config()  __internal__
+	
+Returns the global config array. Internal as you shouldn't need to
+call this (you're setting it, after all). Used internally to make
+CI's get_config() work.
+
+	CI_TestCase::instance()  __internal__
+
+Returns an instance of the current test case. We force phpunit to
+run with backup-globals enabled, so this will always be the instance
+of the currently running test class.
+
+### Going forward
+
+#### 1. Bootstrap Test
+
+Testing common.php should be pretty simple. Include the file, and test the
+functions. May require some tweaking so that we can grab the statics from all
+methods (see is_loaded()). Testing the actual CodeIgniter.php file will most
+likely be an output test for the default view, with some object checking after
+the file runs. Needs consideration.
+
+#### 2. System Test
+
+Testing the core system relies on being able to isolate the core components
+as much as possible. A few of them access other core classes as globals. These
+should be mocked up and easy to manipulate.
+
+All functions in common.php should be a minimal implementation, or and mapped
+to a method in the test's parent class to gives us full control of their output.
+
+#### 3. Application Test:
+
+Not sure yet, needs to handle:
+
+- Libraries
+- Helpers
+- Models
+- MY_* files
+- Controllers (uh...?)
+- Views? (watir, selenium, cucumber?)
+- Database Testing
+
+#### 4. Package Test:
+
+I don't have a clue how this will work.
+
+Needs to be able to handle packages
+that are used multiple times within the application (i.e. EE/Pyro modules)
+as well as packages that are used by multiple applications (library distributions)
diff --git a/tests/codeigniter/Setup_test.php b/tests/codeigniter/Setup_test.php
new file mode 100644
index 0000000..550245f
--- /dev/null
+++ b/tests/codeigniter/Setup_test.php
@@ -0,0 +1,13 @@
+<?php
+
+class Setup_test extends PHPUnit_Framework_TestCase {
+	
+	function test_nonsense()
+	{
+		$this->markTestIncomplete('not implemented');
+		// ensure that our bootstrapped test environment
+		// is a good representation of an isolated CI install
+		//die('here');
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/codeigniter/core/Common_test.php b/tests/codeigniter/core/Common_test.php
new file mode 100644
index 0000000..cec1298
--- /dev/null
+++ b/tests/codeigniter/core/Common_test.php
@@ -0,0 +1,16 @@
+<?php
+
+require_once(BASEPATH.'helpers/email_helper.php');
+
+class Common_test extends CI_TestCase
+{
+	
+	// ------------------------------------------------------------------------
+	
+	public function test_is_php()
+	{
+		$this->assertEquals(TRUE, is_php('1.2.0'));
+		$this->assertEquals(FALSE, is_php('9999.9.9'));
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/codeigniter/core/Config_test.php b/tests/codeigniter/core/Config_test.php
new file mode 100644
index 0000000..30f0cc6
--- /dev/null
+++ b/tests/codeigniter/core/Config_test.php
@@ -0,0 +1,93 @@
+<?php
+
+class Config_test extends CI_TestCase {
+
+	public function set_up()
+	{
+		$cls =& $this->ci_core_class('cfg');
+				
+		// set predictable config values
+		$this->ci_set_config(array(
+			'index_page'		=> 'index.php',
+			'base_url'			=> 'http://example.com/',
+			'subclass_prefix'	=> 'MY_'
+		));
+
+		$this->config = new $cls;	
+	}
+	
+	// --------------------------------------------------------------------
+
+	public function test_item()
+	{
+		$this->assertEquals('http://example.com/', $this->config->item('base_url'));
+
+		// Bad Config value
+		$this->assertFalse($this->config->item('no_good_item'));
+		
+		// Index
+		$this->assertFalse($this->config->item('no_good_item', 'bad_index'));
+		$this->assertFalse($this->config->item('no_good_item', 'default'));
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function test_set_item()
+	{
+		$this->assertFalse($this->config->item('not_yet_set'));
+		
+		$this->config->set_item('not_yet_set', 'is set');
+		
+		$this->assertEquals('is set', $this->config->item('not_yet_set'));
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_slash_item()
+	{
+		// Bad Config value
+		$this->assertFalse($this->config->slash_item('no_good_item'));
+		
+		$this->assertEquals('http://example.com/', $this->config->slash_item('base_url'));
+
+		$this->assertEquals('MY_/', $this->config->slash_item('subclass_prefix'));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_site_url()
+	{
+		$this->assertEquals('http://example.com/index.php', $this->config->site_url());
+		
+		$base_url = $this->config->item('base_url');
+		
+		$this->config->set_item('base_url', '');
+		
+		$q_string = $this->config->item('enable_query_strings');
+		
+		$this->config->set_item('enable_query_strings', FALSE);
+
+		$this->assertEquals('index.php/test', $this->config->site_url('test'));
+		$this->assertEquals('index.php/test/1', $this->config->site_url(array('test', '1')));
+		
+		$this->config->set_item('enable_query_strings', TRUE);
+
+		$this->assertEquals('index.php?test', $this->config->site_url('test'));
+		$this->assertEquals('index.php?0=test&1=1', $this->config->site_url(array('test', '1')));
+		
+		$this->config->set_item('base_url', $base_url);
+
+		$this->assertEquals('http://example.com/index.php?test', $this->config->site_url('test'));
+		
+		// back to home base
+		$this->config->set_item('enable_query_strings', $q_string);				
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_system_url()
+	{
+		$this->assertEquals('http://example.com/system/', $this->config->system_url());
+	}
+
+}
\ No newline at end of file
diff --git a/tests/codeigniter/core/Lang_test.php b/tests/codeigniter/core/Lang_test.php
new file mode 100644
index 0000000..a414f0a
--- /dev/null
+++ b/tests/codeigniter/core/Lang_test.php
@@ -0,0 +1,31 @@
+<?php
+
+class Lang_test extends CI_TestCase {
+	
+	protected $lang;
+	
+	public function set_up()
+	{
+		$loader_cls = $this->ci_core_class('load');
+		$this->ci_instance_var('load', new $loader_cls);
+
+		$cls = $this->ci_core_class('lang');
+		$this->lang = new $cls;
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function test_load()
+	{
+		$this->assertTrue($this->lang->load('profiler', 'english'));
+	}
+	
+	// --------------------------------------------------------------------
+
+	public function test_line()
+	{
+		$this->assertTrue($this->lang->load('profiler', 'english'));
+		$this->assertEquals('URI STRING', $this->lang->line('profiler_uri_string'));
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/codeigniter/core/Loader_test.php b/tests/codeigniter/core/Loader_test.php
new file mode 100644
index 0000000..b86fd34
--- /dev/null
+++ b/tests/codeigniter/core/Loader_test.php
@@ -0,0 +1,271 @@
+<?php
+
+require_once 'vfsStream/vfsStream.php';
+require_once BASEPATH.'/core/Loader.php';
+
+class Extended_Loader extends CI_Loader {
+	
+	/**
+	 * Since we use paths to load up models, views, etc, we need the ability to
+	 * mock up the file system so when core tests are run, we aren't mucking
+	 * in the application directory.  this will give finer grained control over
+	 * these tests.  So yeah, while this looks odd, I need to overwrite protected
+	 * class vars in the loader.  So here we go...
+	 *
+	 * @covers CI_Loader::__construct()
+	 */
+	public function __construct()
+	{
+		vfsStreamWrapper::register();
+		vfsStreamWrapper::setRoot(new vfsStreamDirectory('application'));
+		
+		$this->models_dir 	= vfsStream::newDirectory('models')->at(vfsStreamWrapper::getRoot());
+		$this->libs_dir 	= vfsStream::newDirectory('libraries')->at(vfsStreamWrapper::getRoot());
+		$this->helpers_dir 	= vfsStream::newDirectory('helpers')->at(vfsStreamWrapper::getRoot());
+		$this->views_dir 	= vfsStream::newDirectory('views')->at(vfsStreamWrapper::getRoot());
+		
+		$this->_ci_ob_level  		= ob_get_level();
+		$this->_ci_library_paths	= array(vfsStream::url('application').'/', BASEPATH);
+		$this->_ci_helper_paths 	= array(vfsStream::url('application').'/', BASEPATH);
+		$this->_ci_model_paths 		= array(vfsStream::url('application').'/');
+		$this->_ci_view_paths 		= array(vfsStream::url('application').'/views/' => TRUE);
+	}
+}
+
+
+class Loader_test extends CI_TestCase {
+	
+	private $ci_obj;
+	
+	public function set_up()
+	{
+		// Instantiate a new loader
+		$this->load = new Extended_Loader();
+		
+		// mock up a ci instance
+		$this->ci_obj = new StdClass;
+		
+		// Fix get_instance()
+		$this->ci_instance($this->ci_obj);
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_library()
+	{
+		$this->_setup_config_mock();
+		
+		// Test loading as an array.
+		$this->assertNull($this->load->library(array('table')));
+		$this->assertTrue(class_exists('CI_Table'), 'Table class exists');
+		$this->assertAttributeInstanceOf('CI_Table', 'table', $this->ci_obj);
+		
+		// Test no lib given
+		$this->assertEquals(FALSE, $this->load->library());
+		
+		// Test a string given to params
+		$this->assertEquals(NULL, $this->load->library('table', ' '));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_load_library_in_application_dir()
+	{
+		$this->_setup_config_mock();
+		
+		$content = '<?php class Super_test_library {} ';
+		
+		$model = vfsStream::newFile('Super_test_library.php')->withContent($content)
+														->at($this->load->libs_dir);
+		
+		$this->assertNull($this->load->library('super_test_library'));
+		
+		// Was the model class instantiated.
+		$this->assertTrue(class_exists('Super_test_library'));		
+	}
+	
+	// --------------------------------------------------------------------
+	
+	private function _setup_config_mock()
+	{
+		// Mock up a config object until we
+		// figure out how to test the library configs
+		$config = $this->getMock('CI_Config', NULL, array(), '', FALSE);
+		$config->expects($this->any())
+			   ->method('load')
+			   ->will($this->returnValue(TRUE));
+		
+		// Add the mock to our stdClass
+		$this->ci_instance_var('config', $config);
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_non_existent_model()
+	{
+		$this->setExpectedException(
+			'RuntimeException',
+			'CI Error: Unable to locate the model you have specified: ci_test_nonexistent_model.php'
+			);
+			
+		$this->load->model('ci_test_nonexistent_model.php');
+	}
+
+	// --------------------------------------------------------------------
+	
+	/**
+	 * @coverts CI_Loader::model
+	 */
+	public function test_models()
+	{
+		$this->ci_set_core_class('model', 'CI_Model');
+		
+		$content = '<?php class Unit_test_model extends CI_Model {} ';
+		
+		$model = vfsStream::newFile('unit_test_model.php')->withContent($content)
+														->at($this->load->models_dir);
+		
+		$this->assertNull($this->load->model('unit_test_model'));
+		
+		// Was the model class instantiated.
+		$this->assertTrue(class_exists('Unit_test_model'));
+		
+		// Test no model given
+		$this->assertNull($this->load->model(''));	
+	}
+
+	// --------------------------------------------------------------------
+	
+	// public function testDatabase()
+	// {
+	// 	$this->assertEquals(NULL, $this->load->database());
+	// 	$this->assertEquals(NULL, $this->load->dbutil());		
+	// }
+
+	// --------------------------------------------------------------------
+	
+	/**
+	 * @coverts CI_Loader::view
+	 */
+	public function test_load_view()
+	{
+		$this->ci_set_core_class('output', 'CI_Output');
+		
+		$content = 'This is my test page.  <?php echo $hello; ?>';
+		$view = vfsStream::newFile('unit_test_view.php')->withContent($content)
+														->at($this->load->views_dir);
+		
+		// Use the optional return parameter in this test, so the view is not
+		// run through the output class.
+		$this->assertEquals('This is my test page.  World!',
+		$this->load->view('unit_test_view', array('hello' => "World!"), TRUE));
+		
+	}
+
+	// --------------------------------------------------------------------
+	
+	/**
+	 * @coverts CI_Loader::view
+	 */
+	public function test_non_existent_view()
+	{
+		$this->setExpectedException(
+			'RuntimeException',
+			'CI Error: Unable to load the requested file: ci_test_nonexistent_view.php'
+			);
+			
+		$this->load->view('ci_test_nonexistent_view', array('foo' => 'bar'));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_file()
+	{
+		$content = 'Here is a test file, which we will load now.';
+		$file = vfsStream::newFile('ci_test_mock_file.php')->withContent($content)
+														   ->at($this->load->views_dir);
+		
+		// Just like load->view(), take the output class out of the mix here.
+		$load = $this->load->file(vfsStream::url('application').'/views/ci_test_mock_file.php', 
+								TRUE);
+		
+		$this->assertEquals($content, $load);
+		
+		$this->setExpectedException(
+			'RuntimeException',
+			'CI Error: Unable to load the requested file: ci_test_file_not_exists'
+			);
+		
+		$this->load->file('ci_test_file_not_exists', TRUE);
+		
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_vars()
+	{
+		$vars = array(
+			'foo'	=> 'bar'
+		);
+		
+		$this->assertNull($this->load->vars($vars));
+		$this->assertNull($this->load->vars('foo', 'bar'));
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_helper()
+	{
+		$this->assertEquals(NULL, $this->load->helper('array'));
+		
+		$this->setExpectedException(
+			'RuntimeException',
+			'CI Error: Unable to load the requested file: helpers/bad_helper.php'
+			);
+		
+		$this->load->helper('bad');
+	}
+	
+	// --------------------------------------------------------------------
+
+	public function test_loading_multiple_helpers()
+	{
+		$this->assertEquals(NULL, $this->load->helpers(array('file', 'array', 'string')));
+	}
+	
+	// --------------------------------------------------------------------
+	
+	// public function testLanguage()
+	// {
+	// 	$this->assertEquals(NULL, $this->load->language('test'));
+	// }	
+
+	// --------------------------------------------------------------------
+
+	public function test_load_config()
+	{
+		$this->_setup_config_mock();
+		
+		$this->assertNull($this->load->config('config', FALSE));
+	}
+	
+	// --------------------------------------------------------------------
+
+	public function test_load_bad_config()
+	{
+		$this->_setup_config_mock();
+		
+		$this->setExpectedException(
+			'RuntimeException',
+			'CI Error: The configuration file foobar.php does not exist.'
+			);
+		
+		$this->load->config('foobar', FALSE);
+	}
+
+	// --------------------------------------------------------------------
+	
+	
+	
+	
+}
diff --git a/tests/codeigniter/core/URI_test.php b/tests/codeigniter/core/URI_test.php
new file mode 100644
index 0000000..40252aa
--- /dev/null
+++ b/tests/codeigniter/core/URI_test.php
@@ -0,0 +1,344 @@
+<?php
+
+require BASEPATH.'core/URI.php';
+
+/**
+ * Extend the URI class
+ *  - override contructor
+ *  - override CLI detection
+ */
+class URI_extended extends CI_URI {
+	
+	public function __construct()
+	{
+		$test = CI_TestCase::instance();
+		$cls =& $test->ci_core_class('cfg');
+		
+		// set predictable config values
+		$test->ci_set_config(array(
+			'index_page'		=> 'index.php',
+			'base_url'			=> 'http://example.com/',
+			'subclass_prefix'	=> 'MY_'
+		));
+
+		$this->config = new $cls;	
+
+	}
+	
+	protected function _is_cli_request()
+	{
+		return FALSE;
+	}
+}
+
+class URI_test extends CI_TestCase {
+	
+	public function set_up()
+	{
+		$this->uri = new URI_extended();
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_set_uri_string()
+	{
+		// Slashes get killed
+		$this->uri->_set_uri_string('/');
+		
+		$a = '';
+		$b =& $this->uri->uri_string;
+		
+		$this->assertEquals($a, $b);
+		
+		$this->uri->_set_uri_string('nice/uri');
+		
+		$a = 'nice/uri';
+		
+		$this->assertEquals($a, $b);
+	}
+	
+	// --------------------------------------------------------------------
+
+	public function test_fetch_uri_string()
+	{
+		define('SELF', 'index.php');
+
+		// uri_protocol: AUTO
+		$this->uri->config->set_item('uri_protocol', 'AUTO');
+		
+		// Test a variety of request uris
+		$requests = array(
+			'/index.php/controller/method' => 'controller/method',
+			'/index.php?/controller/method' => 'controller/method',
+			'/index.php?/controller/method/?var=foo' => 'controller/method'
+		);
+		
+		foreach($requests as $request => $expected)
+		{
+			$_SERVER['SCRIPT_NAME'] = '/index.php';
+			$_SERVER['REQUEST_URI'] = $request;
+			
+			$this->uri->_fetch_uri_string();
+			$this->assertEquals($expected, $this->uri->uri_string );
+		}
+		
+		// Test a subfolder
+		$_SERVER['SCRIPT_NAME'] = '/subfolder/index.php';
+		$_SERVER['REQUEST_URI'] = '/subfolder/index.php/controller/method';
+		
+		$this->uri->_fetch_uri_string();
+		
+		$a = 'controller/method';
+		$b = $this->uri->uri_string;
+		
+		$this->assertEquals($a, $b);
+		
+		// death to request uri
+		unset($_SERVER['REQUEST_URI']);
+		
+		// life to path info
+		$_SERVER['PATH_INFO'] = '/controller/method/';
+		
+		$this->uri->_fetch_uri_string();
+		
+		$a = '/controller/method/';
+		$b =& $this->uri->uri_string;
+
+		$this->assertEquals($a, $b);
+		
+		// death to path info
+		// At this point your server must be seriously drunk
+		unset($_SERVER['PATH_INFO']);
+		
+		$_SERVER['QUERY_STRING'] = '/controller/method/';
+		
+		$this->uri->_fetch_uri_string();
+
+		$a = '/controller/method/';
+		$b = $this->uri->uri_string;
+		
+		$this->assertEquals($a, $b);
+		
+		// At this point your server is a labotomy victim
+		
+		unset($_SERVER['QUERY_STRING']);
+		
+		$_GET['/controller/method/'] = '';
+		
+		$this->uri->_fetch_uri_string();
+		$this->assertEquals($a, $b);
+
+		// Test coverage implies that these will work
+		// uri_protocol: REQUEST_URI
+		// uri_protocol: CLI
+				
+	}
+	
+	// --------------------------------------------------------------------
+
+	public function test_explode_segments()
+	{
+		// Lets test the function's ability to clean up this mess
+		$uris = array(
+			'test/uri' => array('test', 'uri'),
+			'/test2/uri2' => array('test2', 'uri2'),
+			'//test3/test3///' => array('test3', 'test3')
+		);
+		
+		foreach($uris as $uri => $a)
+		{
+			$this->uri->segments = array();
+			$this->uri->uri_string = $uri;
+			$this->uri->_explode_segments();
+			
+			$b = $this->uri->segments;
+			
+			$this->assertEquals($a, $b);
+		}
+		
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_filter_uri()
+	{
+		$this->uri->config->set_item('enable_query_strings', FALSE);
+		$this->uri->config->set_item('permitted_uri_chars', 'a-z 0-9~%.:_\-');
+		
+		$str_in = 'abc01239~%.:_-';
+		$str = $this->uri->_filter_uri($str_in);
+
+		$this->assertEquals($str, $str_in);
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_filter_uri_escaping()
+	{
+		// ensure escaping even if dodgey characters are permitted
+		
+		$this->uri->config->set_item('enable_query_strings', FALSE);
+		$this->uri->config->set_item('permitted_uri_chars', 'a-z 0-9~%.:_\-()$');
+
+		$str = $this->uri->_filter_uri('$destroy_app(foo)');
+		
+		$this->assertEquals($str, '&#36;destroy_app&#40;foo&#41;');
+	}
+
+	// --------------------------------------------------------------------
+
+    public function test_filter_uri_throws_error()
+    {
+		$this->setExpectedException('RuntimeException');
+		
+		$this->uri->config->set_item('enable_query_strings', FALSE);
+		$this->uri->config->set_item('permitted_uri_chars', 'a-z 0-9~%.:_\-');
+		$this->uri->_filter_uri('$this()');
+    }
+
+	// --------------------------------------------------------------------
+
+	public function test_remove_url_suffix()
+	{
+		$this->uri->config->set_item('url_suffix', '.html');
+		
+		$this->uri->uri_string = 'controller/method/index.html';
+		$this->uri->_remove_url_suffix();
+		
+		$this->assertEquals($this->uri->uri_string, 'controller/method/index');
+		
+		$this->uri->uri_string = 'controller/method/index.htmlify.html';
+		$this->uri->_remove_url_suffix();
+		
+		$this->assertEquals($this->uri->uri_string, 'controller/method/index.htmlify');
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_segment()
+	{
+		$this->uri->segments = array(1 => 'controller');
+		$this->assertEquals($this->uri->segment(1), 'controller');
+		$this->assertEquals($this->uri->segment(2, 'default'), 'default');
+	}
+	
+	// --------------------------------------------------------------------
+
+	public function test_rsegment()
+	{
+		$this->uri->rsegments = array(1 => 'method');
+		$this->assertEquals($this->uri->rsegment(1), 'method');
+		$this->assertEquals($this->uri->rsegment(2, 'default'), 'default');
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_uri_to_assoc()
+	{
+		$this->uri->segments = array('a', '1', 'b', '2', 'c', '3');
+		
+		$a = array('a' => '1', 'b' => '2', 'c' => '3');
+		$b = $this->uri->uri_to_assoc(1);
+		$this->assertEquals($a, $b);
+		
+		$a = array('b' => '2', 'c' => '3');
+		$b = $this->uri->uri_to_assoc(3);
+		$this->assertEquals($a, $b);
+		
+		
+		$this->uri->keyval = array(); // reset cache
+				
+		$this->uri->segments = array('a', '1', 'b', '2', 'c');
+		
+		$a = array('a' => '1', 'b' => '2', 'c' => FALSE);
+		$b = $this->uri->uri_to_assoc(1);
+		$this->assertEquals($a, $b);
+		
+		$this->uri->keyval = array(); // reset cache
+		
+		$this->uri->segments = array('a', '1');
+		
+		// test default
+		$a = array('a' => '1', 'b' => FALSE);
+		$b = $this->uri->uri_to_assoc(1, array('a', 'b'));
+		$this->assertEquals($a, $b);
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_ruri_to_assoc()
+	{
+		$this->uri->rsegments = array('x', '1', 'y', '2', 'z', '3');
+		
+		$a = array('x' => '1', 'y' => '2', 'z' => '3');
+		$b = $this->uri->ruri_to_assoc(1);
+		$this->assertEquals($a, $b);
+		
+		$a = array('y' => '2', 'z' => '3');
+		$b = $this->uri->ruri_to_assoc(3);
+		$this->assertEquals($a, $b);
+		
+		
+		$this->uri->keyval = array(); // reset cache
+				
+		$this->uri->rsegments = array('x', '1', 'y', '2', 'z');
+		
+		$a = array('x' => '1', 'y' => '2', 'z' => FALSE);
+		$b = $this->uri->ruri_to_assoc(1);
+		$this->assertEquals($a, $b);
+		
+		$this->uri->keyval = array(); // reset cache
+		
+		$this->uri->rsegments = array('x', '1');
+		
+		// test default
+		$a = array('x' => '1', 'y' => FALSE);
+		$b = $this->uri->ruri_to_assoc(1, array('x', 'y'));
+		$this->assertEquals($a, $b);
+
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_assoc_to_uri()
+	{
+		$this->uri->config->set_item('uri_string_slashes', 'none');
+		
+		$arr = array('a' => 1, 'b' => 2);
+		$a = 'a/1/b/2';
+		$b = $this->uri->assoc_to_uri($arr);
+		$this->assertEquals($a, $b);
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_slash_segment()
+	{
+		$this->uri->segments[1] = 'segment';
+		$this->uri->rsegments[1] = 'segment';
+
+		$a = '/segment/';
+		$b = $this->uri->slash_segment(1, 'both');
+		$this->assertEquals($a, $b);
+		$b = $this->uri->slash_rsegment(1, 'both');
+		$this->assertEquals($a, $b);
+		
+		$a = '/segment';
+		$b = $this->uri->slash_segment(1, 'leading');
+		$this->assertEquals($a, $b);
+		$b = $this->uri->slash_rsegment(1, 'leading');
+		$this->assertEquals($a, $b);
+		
+		$a = 'segment/';
+		$b = $this->uri->slash_segment(1, 'trailing');
+		$this->assertEquals($a, $b);
+		$b = $this->uri->slash_rsegment(1, 'trailing');
+		$this->assertEquals($a, $b);
+	}
+
+
+}
+// END URI_test Class
+
+/* End of file URI_test.php */
+/* Location: ./tests/core/URI_test.php */
diff --git a/tests/codeigniter/helpers/array_helper_test.php b/tests/codeigniter/helpers/array_helper_test.php
new file mode 100644
index 0000000..62559de
--- /dev/null
+++ b/tests/codeigniter/helpers/array_helper_test.php
@@ -0,0 +1,49 @@
+<?php
+
+// OLD TEST FORMAT: DO NOT COPY
+
+require_once(BASEPATH.'helpers/array_helper.php');
+
+class Array_helper_test extends CI_TestCase
+{
+	public function set_up()
+	{
+		$this->my_array = array(
+			'foo'		=> 'bar',
+			'sally'		=> 'jim',
+			'maggie'	=> 'bessie',
+			'herb'		=> 'cook'
+		);
+	}
+	
+	// ------------------------------------------------------------------------
+	
+	public function test_element_with_existing_item()
+	{	
+		$this->assertEquals(FALSE, element('testing', $this->my_array));
+		
+		$this->assertEquals('not set', element('testing', $this->my_array, 'not set'));
+		
+		$this->assertEquals('bar', element('foo', $this->my_array));
+	}
+	
+	// ------------------------------------------------------------------------	
+
+	public function test_random_element()
+	{
+		// Send a string, not an array to random_element
+		$this->assertEquals('my string', random_element('my string'));
+		
+		// Test sending an array
+		$this->assertEquals(TRUE, in_array(random_element($this->my_array), $this->my_array));
+	}
+
+	// ------------------------------------------------------------------------	
+	
+	public function test_elements()
+	{
+		$this->assertEquals(TRUE, is_array(elements('test', $this->my_array)));
+		$this->assertEquals(TRUE, is_array(elements('foo', $this->my_array)));
+	}
+
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/date_helper_test.php b/tests/codeigniter/helpers/date_helper_test.php
new file mode 100644
index 0000000..662d164
--- /dev/null
+++ b/tests/codeigniter/helpers/date_helper_test.php
@@ -0,0 +1,284 @@
+<?php
+require_once BASEPATH.'helpers/date_helper.php';
+
+class Date_helper_test extends CI_TestCase
+{
+	// ------------------------------------------------------------------------
+
+	public function test_now_local()
+	{
+		// This stub job, is simply to cater $config['time_reference']
+		$config = $this->getMock('CI_Config');
+		$config->expects($this->any())
+			   ->method('item')
+			   ->will($this->returnValue('local'));
+		
+		// Add the stub to our test instance
+		$this->ci_instance_var('config', $config);
+
+		$expected = time();
+		$test = now();
+		$this->assertEquals($expected, $test);
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_now_gmt()
+	{
+		// This stub job, is simply to cater $config['time_reference']
+		$config = $this->getMock('CI_Config');
+		$config->expects($this->any())
+			   ->method('item')
+			   ->will($this->returnValue('gmt'));
+		
+		// Add the stub to our stdClass
+		$this->ci_instance_var('config', $config);
+
+		$t = time();
+		$expected = mktime(gmdate("H", $t), gmdate("i", $t), gmdate("s", $t), gmdate("m", $t), gmdate("d", $t), gmdate("Y", $t));
+		$test = now();
+		$this->assertEquals($expected, $test);
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_mdate()
+	{
+		$time = time();
+		$expected = date("Y-m-d - h:i a", $time);
+		$test = mdate("%Y-%m-%d - %h:%i %a", $time);
+		$this->assertEquals($expected, $test);
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_rfc822()
+	{
+		$time = time();
+		$format = 'DATE_RFC822';
+		$expected = date("D, d M y H:i:s O", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_atom()
+	{
+		$time = time();
+		$format = 'DATE_ATOM';
+		$expected = date("Y-m-d\TH:i:sO", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_cookie()
+	{
+		$time = time();
+		$format = 'DATE_COOKIE';
+		$expected = date("l, d-M-y H:i:s \U\T\C", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_iso8601()
+	{
+		$time = time();
+		$format = 'DATE_ISO8601';
+		$expected = date("Y-m-d\TH:i:sO", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_rfc850()
+	{
+		$time = time();
+		$format = 'DATE_RFC850';
+		$expected = date("l, d-M-y H:i:s \U\T\C", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_rfc1036()
+	{
+		$time = time();
+		$format = 'DATE_RFC1036';
+		$expected = date("D, d M y H:i:s O", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_rfc1123()
+	{
+		$time = time();
+		$format = 'DATE_RFC1123';
+		$expected = date("D, d M Y H:i:s O", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_rfc2822()
+	{
+		$time = time();
+		$format = 'DATE_RFC2822';
+		$expected = date("D, d M Y H:i:s O", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_rss()
+	{
+		$time = time();
+		$format = 'DATE_RSS';
+		$expected = date("D, d M Y H:i:s O", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_standard_date_w3c()
+	{
+		$time = time();
+		$format = 'DATE_W3C';
+		$expected = date("Y-m-d\TH:i:sO", $time);
+		$this->assertEquals($expected, standard_date($format, $time));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_timespan()
+	{
+		$loader_cls = $this->ci_core_class('load');
+		$this->ci_instance_var('load', new $loader_cls);
+
+		$lang_cls = $this->ci_core_class('lang');
+		$this->ci_instance_var('lang', new $lang_cls);
+
+		$this->assertEquals('1 Second', timespan(time(), time()+1));
+		$this->assertEquals('1 Minute', timespan(time(), time()+60));
+		$this->assertEquals('1 Hour', timespan(time(), time()+3600));
+		$this->assertEquals('2 Hours', timespan(time(), time()+7200));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_days_in_month()
+	{
+		$this->assertEquals(30, days_in_month(06, 2005));
+		$this->assertEquals(28, days_in_month(02, 2011));
+		$this->assertEquals(29, days_in_month(02, 2012));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_local_to_gmt()
+	{
+		$t = time();
+		$expected = mktime(gmdate("H", $t), gmdate("i", $t), gmdate("s", $t), gmdate("m", $t), gmdate("d", $t), gmdate("Y", $t));
+		$this->assertEquals($expected, local_to_gmt($t));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_gmt_to_local()
+	{
+		$timestamp = '1140153693';
+		$timezone = 'UM8';
+		$daylight_saving = TRUE;
+
+		$this->assertEquals(1140128493, gmt_to_local($timestamp, $timezone, $daylight_saving));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_mysql_to_unix()
+	{
+		$time = time();
+		$this->assertEquals($time, 
+				mysql_to_unix(date("Y-m-d H:i:s", $time)));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_unix_to_human()
+	{
+		$time = time();
+		$this->assertEquals(date("Y-m-d h:i A", $time), unix_to_human($time));
+		$this->assertEquals(date("Y-m-d h:i:s A", $time), unix_to_human($time, TRUE, 'us'));
+		$this->assertEquals(date("Y-m-d H:i:s", $time), unix_to_human($time, TRUE, 'eu'));
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_human_to_unix()
+	{
+		$date = '2000-12-31 10:00:00 PM';
+		$expected = strtotime($date);
+		$this->assertEquals($expected, human_to_unix($date));
+		$this->assertFalse(human_to_unix());
+	}
+
+	// ------------------------------------------------------------------------
+
+	public function test_timezones()
+	{
+		$zones = array(
+			'UM12'		=> -12,
+			'UM11'		=> -11,
+			'UM10'		=> -10,
+			'UM95'		=> -9.5,
+			'UM9'		=> -9,
+			'UM8'		=> -8,
+			'UM7'		=> -7,
+			'UM6'		=> -6,
+			'UM5'		=> -5,
+			'UM45'		=> -4.5,
+			'UM4'		=> -4,
+			'UM35'		=> -3.5,
+			'UM3'		=> -3,
+			'UM2'		=> -2,
+			'UM1'		=> -1,
+			'UTC'		=> 0,
+			'UP1'		=> +1,
+			'UP2'		=> +2,
+			'UP3'		=> +3,
+			'UP35'		=> +3.5,
+			'UP4'		=> +4,
+			'UP45'		=> +4.5,
+			'UP5'		=> +5,
+			'UP55'		=> +5.5,
+			'UP575'		=> +5.75,
+			'UP6'		=> +6,
+			'UP65'		=> +6.5,
+			'UP7'		=> +7,
+			'UP8'		=> +8,
+			'UP875'		=> +8.75,
+			'UP9'		=> +9,
+			'UP95'		=> +9.5,
+			'UP10'		=> +10,
+			'UP105'		=> +10.5,
+			'UP11'		=> +11,
+			'UP115'		=> +11.5,
+			'UP12'		=> +12,
+			'UP1275'	=> +12.75,
+			'UP13'		=> +13,
+			'UP14'		=> +14
+		);
+
+		foreach ($zones AS $test => $expected)
+		{
+			$this->assertEquals($expected, timezones($test));
+		}
+
+		$this->assertArrayHasKey('UP3', timezones());
+		$this->assertEquals(0, timezones('non_existant'));
+	}
+}
+
+/* End of file date_helper_test.php */
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/directory_helper_test.php b/tests/codeigniter/helpers/directory_helper_test.php
new file mode 100644
index 0000000..3fae81b
--- /dev/null
+++ b/tests/codeigniter/helpers/directory_helper_test.php
@@ -0,0 +1,42 @@
+<?php
+
+require_once 'vfsStream/vfsStream.php';
+require BASEPATH.'helpers/directory_helper.php';
+
+class Directory_helper_test extends CI_TestCase
+{
+	public function set_up()
+	{
+		vfsStreamWrapper::register();
+		vfsStreamWrapper::setRoot(new vfsStreamDirectory('testDir'));
+		
+		$this->_test_dir = vfsStreamWrapper::getRoot();
+	}	
+	
+	public function test_directory_map()
+	{
+		$structure = array('libraries' => array('benchmark.html' => '', 'database' =>
+			array('active_record.html' => '', 'binds.html' => ''), 'email.html' => '', '.hiddenfile.txt' => ''));
+		
+		vfsStream::create($structure, $this->_test_dir);
+
+		// test default recursive behavior
+		$expected = array('libraries' => array('benchmark.html', 'database' =>
+			array('active_record.html', 'binds.html'), 'email.html'));
+			
+		$this->assertEquals($expected, directory_map(vfsStream::url('testDir')));
+
+		// test recursion depth behavior
+		$expected = array('libraries');
+			
+		$this->assertEquals($expected, directory_map(vfsStream::url('testDir'), 1));
+
+		// test detection of hidden files
+		$expected = array('libraries' => array('benchmark.html', 'database' =>
+			array('active_record.html', 'binds.html'), 'email.html', '.hiddenfile.txt'));
+			
+		$this->assertEquals($expected, directory_map(vfsStream::url('testDir'), FALSE, TRUE));
+  }  
+}
+
+/* End of file directory_helper_test.php */
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/email_helper_test.php b/tests/codeigniter/helpers/email_helper_test.php
new file mode 100644
index 0000000..7324e81
--- /dev/null
+++ b/tests/codeigniter/helpers/email_helper_test.php
@@ -0,0 +1,16 @@
+<?php
+
+require_once(BASEPATH.'helpers/email_helper.php');
+
+class Email_helper_test extends CI_TestCase
+{
+	
+	public function test_valid_email()
+	{
+		$this->assertEquals(FALSE, valid_email('test'));
+		$this->assertEquals(FALSE, valid_email('test@test@test.com'));
+		$this->assertEquals(TRUE, valid_email('test@test.com'));
+		$this->assertEquals(TRUE, valid_email('my.test@test.com'));
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/file_helper_test.php b/tests/codeigniter/helpers/file_helper_test.php
new file mode 100644
index 0000000..a596a03
--- /dev/null
+++ b/tests/codeigniter/helpers/file_helper_test.php
@@ -0,0 +1,157 @@
+<?php
+
+require_once 'vfsStream/vfsStream.php';
+require BASEPATH.'helpers/file_helper.php';
+
+class File_helper_Test extends CI_TestCase
+{
+	public function set_up()
+	{
+		vfsStreamWrapper::register();
+		vfsStreamWrapper::setRoot(new vfsStreamDirectory('testDir'));
+		
+		$this->_test_dir = vfsStreamWrapper::getRoot();
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function test_read_file()
+	{
+		$this->assertFalse(read_file('does_not_exist'));
+		
+		$content = 'Jack and Jill went up the mountain to fight a billy goat.';
+		
+		$file = vfsStream::newFile('my_file.txt')->withContent($content)
+												 ->at($this->_test_dir);
+		
+		$this->assertEquals($content, read_file(vfsStream::url('my_file.txt')));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_octal_permissions()
+	{
+		$content = 'Jack and Jill went up the mountain to fight a billy goat.';
+		
+		$file = vfsStream::newFile('my_file.txt', 0777)->withContent($content)
+												 ->lastModified(time() - 86400)
+												 ->at($this->_test_dir);
+		
+		$this->assertEquals('777', octal_permissions($file->getPermissions()));		
+	}
+
+	// --------------------------------------------------------------------	
+	
+	/**
+	 * More tests should happen here, since I'm not hitting the whole function.
+	 */
+	public function test_symbolic_permissions()
+	{
+		$content = 'Jack and Jill went up the mountain to fight a billy goat.';
+		
+		$file = vfsStream::newFile('my_file.txt', 0777)->withContent($content)
+												 ->lastModified(time() - 86400)
+												 ->at($this->_test_dir);
+												
+		$this->assertEquals('urwxrwxrwx', symbolic_permissions($file->getPermissions()));		
+	}
+
+	// --------------------------------------------------------------------	
+	
+	public function test_get_mime_by_extension()
+	{
+		$content = 'Jack and Jill went up the mountain to fight a billy goat.';
+		
+		$file = vfsStream::newFile('my_file.txt', 0777)->withContent($content)
+												 ->lastModified(time() - 86400)
+												 ->at($this->_test_dir);
+												
+		$this->assertEquals('text/plain', 
+						get_mime_by_extension(vfsStream::url('my_file.txt')));
+						
+		// Test a mime with an array, such as png		
+		$file = vfsStream::newFile('foo.png')->at($this->_test_dir);
+		
+		$this->assertEquals('image/png', get_mime_by_extension(vfsStream::url('foo.png')));			
+			
+		// Test a file not in the mimes array
+		$file = vfsStream::newFile('foo.blarfengar')->at($this->_test_dir);
+		
+		$this->assertFalse(get_mime_by_extension(vfsStream::url('foo.blarfengar')));
+	}
+
+	// --------------------------------------------------------------------	
+
+	public function test_get_file_info()
+	{
+		// Test Bad File
+		$this->assertFalse(get_file_info('i_am_bad_boo'));
+		
+		// Test the rest
+		
+		// First pass in an array
+		$vals = array(
+			'name', 'server_path', 'size', 'date',
+			'readable', 'writable', 'executable',  'fileperms'
+		);
+		
+		$this->_test_get_file_info($vals);
+
+		// Test passing in vals as a string.
+		$vals = 'name, server_path, size, date, readable, writable, executable, fileperms';
+		$this->_test_get_file_info($vals);
+	}
+	
+	private function _test_get_file_info($vals)
+	{
+		$content = 'Jack and Jill went up the mountain to fight a billy goat.';
+		$last_modified = time() - 86400;
+		
+		$file = vfsStream::newFile('my_file.txt', 0777)->withContent($content)
+												 ->lastModified($last_modified)
+												 ->at($this->_test_dir);
+		
+		$ret_values = array(
+			'name'			=> 'my_file.txt', 
+			'server_path'	=> 'vfs://my_file.txt', 
+			'size'			=> 57, 
+			'date'			=> $last_modified, 
+			'readable'		=> TRUE,
+			'writable'		=> TRUE, 
+			'executable'	=> TRUE, 
+			'fileperms'		=> 33279
+		);
+		
+		$info = get_file_info(vfsStream::url('my_file.txt'), $vals);
+		
+		foreach ($info as $k => $v)
+		{
+			$this->assertEquals($ret_values[$k], $v);
+		}
+	}
+	
+	// --------------------------------------------------------------------	
+
+	// Skipping for now, as it's not implemented in vfsStreamWrapper
+	// flock(): vfsStreamWrapper::stream_lock is not implemented!
+	
+	// public function test_write_file()
+	// {
+	// 	if ( ! defined('FOPEN_WRITE_CREATE_DESTRUCTIVE'))
+	// 	{
+	// 		define('FOPEN_WRITE_CREATE_DESTRUCTIVE', 'wb');
+	// 	}
+	// 	
+	// 	$content = 'Jack and Jill went up the mountain to fight a billy goat.';
+	// 	
+	// 	$file = vfsStream::newFile('write.txt', 0777)->withContent('')
+	// 											 	 ->lastModified(time() - 86400)
+	// 											 	 ->at($this->_test_dir);
+	// 	
+	// 	$this->assertTrue(write_file(vfsStream::url('write.txt'), $content));
+	// 		
+	// }
+
+	// --------------------------------------------------------------------		
+	
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/html_helper_test.php b/tests/codeigniter/helpers/html_helper_test.php
new file mode 100644
index 0000000..553fc2b
--- /dev/null
+++ b/tests/codeigniter/helpers/html_helper_test.php
@@ -0,0 +1,78 @@
+<?php
+
+require_once(BASEPATH.'helpers/html_helper.php');
+
+class Html_helper_test extends CI_TestCase
+{
+	
+	// ------------------------------------------------------------------------
+	
+	public function test_br()
+	{
+		$this->assertEquals('<br /><br />', br(2));
+	}
+	
+	// ------------------------------------------------------------------------
+	
+	public function test_heading()
+	{
+		$this->assertEquals('<h1>foobar</h1>', heading('foobar'));
+		$this->assertEquals('<h2 class="bar">foobar</h2>', heading('foobar', 2, 'class="bar"'));
+	}
+
+	// ------------------------------------------------------------------------
+	
+	public function test_Ul()
+	{
+		$expect = <<<EOH
+<ul>
+  <li>foo</li>
+  <li>bar</li>
+</ul>
+
+EOH;
+
+		$expect = ltrim($expect);
+
+		$list = array('foo', 'bar');
+		
+		$this->assertEquals($expect, ul($list));
+
+
+		$expect = <<<EOH
+<ul class="test">
+  <li>foo</li>
+  <li>bar</li>
+</ul>
+
+EOH;
+
+		$expect = ltrim($expect);
+
+		$list = array('foo', 'bar');
+
+		$this->assertEquals($expect, ul($list, 'class="test"'));
+
+		$this->assertEquals($expect, ul($list, array('class' => 'test')));
+	}
+	
+	// ------------------------------------------------------------------------
+
+	public function test_NBS()
+	{
+		$this->assertEquals('&nbsp;&nbsp;&nbsp;', nbs(3));
+	}
+
+	// ------------------------------------------------------------------------
+	
+	public function test_meta()
+	{
+		$this->assertEquals("<meta name=\"test\" content=\"foo\" />\n", meta('test', 'foo'));
+		
+		$expect = "<meta name=\"foo\" content=\"\" />\n";
+		
+		$this->assertEquals($expect, meta(array('name' => 'foo')));
+		
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/inflector_helper_test.php b/tests/codeigniter/helpers/inflector_helper_test.php
new file mode 100644
index 0000000..472e28a
--- /dev/null
+++ b/tests/codeigniter/helpers/inflector_helper_test.php
@@ -0,0 +1,93 @@
+<?php
+
+require_once(BASEPATH.'helpers/inflector_helper.php');
+
+class Inflector_helper_test extends CI_TestCase {
+	
+	
+	public function test_singular()
+	{
+		$strs = array(
+			'tellies'		=> 'telly',
+			'smellies'		=> 'smelly',
+			'abjectnesses'	=> 'abjectness',
+			'smells'		=> 'smell',
+			'equipment'		=> 'equipment'
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, singular($str));
+		}
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function test_plural()
+	{
+		$strs = array(
+			'telly'			=> 'tellies',
+			'smelly'		=> 'smellies',
+			'abjectness'	=> 'abjectnesses', // ref : http://en.wiktionary.org/wiki/abjectnesses
+			'smell'			=> 'smells',
+			'witch'			=> 'witches',
+			'equipment'		=> 'equipment'
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, plural($str));
+		}		
+	}	
+
+	// --------------------------------------------------------------------
+	
+	public function test_camelize()
+	{
+		$strs = array(
+			'this is the string'	=> 'thisIsTheString',
+			'this is another one'	=> 'thisIsAnotherOne',
+			'i-am-playing-a-trick'	=> 'i-am-playing-a-trick',
+			'what_do_you_think-yo?'	=> 'whatDoYouThink-yo?',
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, camelize($str));
+		}
+	}	
+
+	// --------------------------------------------------------------------
+	
+	public function test_underscore()
+	{
+		$strs = array(
+			'this is the string'	=> 'this_is_the_string',
+			'this is another one'	=> 'this_is_another_one',
+			'i-am-playing-a-trick'	=> 'i-am-playing-a-trick',
+			'what_do_you_think-yo?'	=> 'what_do_you_think-yo?',
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, underscore($str));
+		}
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_humanize()
+	{
+		$strs = array(
+			'this_is_the_string'	=> 'This Is The String',
+			'this_is_another_one'	=> 'This Is Another One',
+			'i-am-playing-a-trick'	=> 'I-am-playing-a-trick',
+			'what_do_you_think-yo?'	=> 'What Do You Think-yo?',
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, humanize($str));
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/number_helper_test.php b/tests/codeigniter/helpers/number_helper_test.php
new file mode 100644
index 0000000..3322b24
--- /dev/null
+++ b/tests/codeigniter/helpers/number_helper_test.php
@@ -0,0 +1,78 @@
+<?php
+
+require_once BASEPATH.'helpers/number_helper.php';
+
+class Number_helper_test extends CI_TestCase
+{
+	
+	public function set_up()
+	{
+		// Grab the core lang class
+		$lang_cls = $this->ci_core_class('lang');
+		
+		// Mock away load, too much going on in there,
+		// we'll just check for the expected parameter
+		
+		$lang = $this->getMock($lang_cls, array('load'));
+		$lang->expects($this->once())
+			 ->method('load')
+			 ->with($this->equalTo('number'));
+		
+		// Assign the proper language array
+		
+		$lang->language = $this->_get_lang('number');
+		
+		// We don't have a controller, so just create
+		// a cheap class to act as our super object.
+		// Make sure it has a lang attribute.
+		
+		$obj = new StdClass;
+		$obj->lang = $lang;
+		$this->ci_instance($obj);
+	}
+	
+	// Quick helper to actually grab the language
+	// file. Consider moving this to ci_testcase?
+	public function _get_lang($name)
+	{
+		require BASEPATH.'language/english/'.$name.'_lang.php';
+		return $lang;
+	}
+	
+	public function test_byte_format()
+	{
+		$this->assertEquals('456 Bytes', byte_format(456));
+	}
+	
+	public function test_kb_format()
+	{
+		$this->assertEquals('4.5 KB', byte_format(4567));
+	}
+	
+	public function test_kb_format_medium()
+	{
+		$this->assertEquals('44.6 KB', byte_format(45678));
+	}
+	
+	public function test_kb_format_large()
+	{
+		$this->assertEquals('446.1 KB', byte_format(456789));
+	}
+	
+	public function test_mb_format()
+	{
+		$this->assertEquals('3.3 MB', byte_format(3456789));
+	}
+	
+	public function test_gb_format()
+	{
+		$this->assertEquals('1.8 GB', byte_format(1932735283.2));
+	}
+	
+	public function test_tb_format()
+	{
+		$this->assertEquals('112,283.3 TB', byte_format(123456789123456789));
+	}
+}
+
+// EOF
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/path_helper_test.php b/tests/codeigniter/helpers/path_helper_test.php
new file mode 100644
index 0000000..2e6cc63
--- /dev/null
+++ b/tests/codeigniter/helpers/path_helper_test.php
@@ -0,0 +1,29 @@
+<?php
+
+require BASEPATH . 'helpers/path_helper.php';
+
+class Path_helper_test extends CI_TestCase 
+{
+	public function test_set_realpath()
+	{				
+		$expected = getcwd() . DIRECTORY_SEPARATOR;
+		$this->assertEquals($expected, set_realpath(getcwd()));		
+	}
+
+	public function test_set_realpath_nonexistent_directory()
+	{
+		$expected = '/path/to/nowhere';
+		$this->assertEquals($expected, set_realpath('/path/to/nowhere', FALSE));
+	}
+
+	public function test_set_realpath_error_trigger()
+	{
+		$this->setExpectedException(
+				'RuntimeException', 'CI Error: Not a valid path: /path/to/nowhere'
+		);
+
+		set_realpath('/path/to/nowhere', TRUE);
+	}
+}
+
+/* End of file path_helper_test.php */
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/string_helper_test.php b/tests/codeigniter/helpers/string_helper_test.php
new file mode 100644
index 0000000..a884d62
--- /dev/null
+++ b/tests/codeigniter/helpers/string_helper_test.php
@@ -0,0 +1,144 @@
+<?php
+
+require_once(BASEPATH.'helpers/string_helper.php');
+
+class String_helper_test extends CI_TestCase
+{
+	public function test_strip_slashes()
+	{
+		$expected = array(
+			"Is your name O'reilly?", 
+			"No, my name is O'connor."
+		);
+		
+		$str = array(
+			"Is your name O\'reilly?",
+			"No, my name is O\'connor."
+		);
+		
+		$this->assertEquals($expected, strip_slashes($str));
+	}
+	
+	public function test_trim_slashes()
+	{
+		$strs = array(
+			'//Slashes//\/'	=> 'Slashes//\\',
+			'/var/www/html/'	=> 'var/www/html'
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, trim_slashes($str));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_strip_quotes()
+	{
+		$strs = array(
+			'"me oh my!"'		=> 'me oh my!',
+			"it's a winner!"	=> 'its a winner!',
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, strip_quotes($str));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_quotes_to_entities()
+	{
+		$strs = array(
+			'"me oh my!"'		=> '&quot;me oh my!&quot;',
+			"it's a winner!"	=> 'it&#39;s a winner!',
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, quotes_to_entities($str));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_reduce_double_slashes()
+	{
+		$strs = array(
+			'http://codeigniter.com'		=> 'http://codeigniter.com',
+			'//var/www/html/example.com/'	=> '/var/www/html/example.com/',
+			'/var/www/html//index.php'		=> '/var/www/html/index.php'
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, reduce_double_slashes($str));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_reduce_multiples()
+	{
+		$strs = array(
+			'Fred, Bill,, Joe, Jimmy'	=> 'Fred, Bill, Joe, Jimmy',
+			'Ringo, John, Paul,,'		=> 'Ringo, John, Paul,'
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, reduce_multiples($str));
+		}
+
+		$strs = array(
+			'Fred, Bill,, Joe, Jimmy'	=> 'Fred, Bill, Joe, Jimmy',
+			'Ringo, John, Paul,,'		=> 'Ringo, John, Paul'
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, reduce_multiples($str, ',', TRUE));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_repeater()
+	{
+		$strs = array(
+			'a'			=> 'aaaaaaaaaa',
+			'&nbsp;'	=> '&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;',
+			'<br>'		=> '<br><br><br><br><br><br><br><br><br><br>'
+
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, repeater($str, 10));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_random_string()
+	{
+		$this->assertEquals(16, strlen(random_string('alnum', 16)));
+		$this->assertEquals(32, strlen(random_string('unique', 16)));
+		$this->assertInternalType('string', random_string('numeric', 16));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_increment_string()
+	{
+		$this->assertEquals('my-test_1', increment_string('my-test'));
+		$this->assertEquals('my-test-1', increment_string('my-test', '-'));
+		$this->assertEquals('file_5', increment_string('file_4'));
+		$this->assertEquals('file-5', increment_string('file-4', '-'));
+		$this->assertEquals('file-5', increment_string('file-4', '-'));
+		$this->assertEquals('file-1', increment_string('file', '-', '1'));
+		$this->assertEquals(124, increment_string('123', ''));
+	}
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/text_helper_test.php b/tests/codeigniter/helpers/text_helper_test.php
new file mode 100644
index 0000000..a0866e6
--- /dev/null
+++ b/tests/codeigniter/helpers/text_helper_test.php
@@ -0,0 +1,159 @@
+<?php
+
+require_once(BASEPATH.'helpers/text_helper.php');
+
+class Text_helper_test extends CI_TestCase
+{
+	private $_long_string;
+	
+	public function set_up()
+	{
+		$this->_long_string = 'Once upon a time, a framework had no tests.  It sad.  So some nice people began to write tests.  The more time that went on, the happier it became.  Everyone was happy.';
+	}
+	
+	// ------------------------------------------------------------------------
+	
+	public function test_word_limiter()
+	{
+		$this->assertEquals('Once upon a time,&#8230;', word_limiter($this->_long_string, 4));
+		$this->assertEquals('Once upon a time,&hellip;', word_limiter($this->_long_string, 4, '&hellip;'));
+		$this->assertEquals('', word_limiter('', 4));
+	}
+
+	// ------------------------------------------------------------------------	
+	
+	public function test_character_limiter()
+	{
+		$this->assertEquals('Once upon a time, a&#8230;', character_limiter($this->_long_string, 20));
+		$this->assertEquals('Once upon a time, a&hellip;', character_limiter($this->_long_string, 20, '&hellip;'));
+		$this->assertEquals('Short', character_limiter('Short', 20));
+		$this->assertEquals('Short', character_limiter('Short', 5));
+	}
+
+	// ------------------------------------------------------------------------	
+	
+	public function test_ascii_to_entities()
+	{
+		$strs = array(
+			'“‘ “test”'			=> '&#8220;&#8216; &#8220;test&#8221;',
+			'†¥¨ˆøåß∂ƒ©˙∆˚¬'	=> '&#8224;&#165;&#168;&#710;&#248;&#229;&#223;&#8706;&#402;&#169;&#729;&#8710;&#730;&#172;'
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, ascii_to_entities($str));
+		}
+	}
+
+	// ------------------------------------------------------------------------	
+
+	public function test_entities_to_ascii()
+	{
+		$strs = array(
+			'&#8220;&#8216; &#8220;test&#8221;' => '“‘ “test”',
+			'&#8224;&#165;&#168;&#710;&#248;&#229;&#223;&#8706;&#402;&#169;&#729;&#8710;&#730;&#172;' => '†¥¨ˆøåß∂ƒ©˙∆˚¬'
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, entities_to_ascii($str));
+		}		
+	}
+	
+	// ------------------------------------------------------------------------	
+	
+	function test_convert_accented_characters() 
+	{
+		$this->assertEquals('AAAeEEEIIOOEUUUeY', convert_accented_characters('ÀÂÄÈÊËÎÏÔŒÙÛÜŸ'));
+		$this->assertEquals('a e i o u n ue', convert_accented_characters('á é í ó ú ñ ü'));
+	}
+
+	// ------------------------------------------------------------------------	
+	
+	public function test_censored_words()
+	{
+		$censored = array('boob', 'nerd', 'ass', 'fart');
+		
+		$strs = array(
+			'Ted bobbled the ball' 			=> 'Ted bobbled the ball',
+			'Jake is a nerdo'				=> 'Jake is a nerdo',
+			'The borg will assimilate you'	=> 'The borg will assimilate you',
+			'Did Mary Fart?'				=> 'Did Mary $*#?',
+			'Jake is really a boob'			=> 'Jake is really a $*#'
+		);
+		
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, word_censor($str, $censored, '$*#'));
+		}
+		
+		// test censored words being sent as a string
+		$this->assertEquals('test', word_censor('test', 'test'));
+	}
+
+	// ------------------------------------------------------------------------	
+
+	public function test_highlight_code()
+	{
+		$code = '<?php var_dump($this); ?>';
+		$expect = "<code><span style=\"color: #000000\">\n<span style=\"color: #0000BB\">&lt;?php&nbsp;var_dump</span><span style=\"color: #007700\">(</span><span style=\"color: #0000BB\">\$this</span><span style=\"color: #007700\">);&nbsp;</span><span style=\"color: #0000BB\">?&gt;&nbsp;</span>\n</span>\n</code>";
+
+		$this->assertEquals($expect, highlight_code($code));
+	}
+
+	// ------------------------------------------------------------------------	
+
+	public function test_highlight_phrase()
+	{
+		$strs = array(
+			'this is a phrase'			=> '<strong>this is</strong> a phrase',
+			'this is another'			=> '<strong>this is</strong> another',
+			'Gimme a test, Sally'		=> 'Gimme a test, Sally',
+			'Or tell me what this is'	=> 'Or tell me what <strong>this is</strong>',
+			''							=> ''
+		);
+		
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, highlight_phrase($str, 'this is'));
+		}
+	}
+
+	// ------------------------------------------------------------------------	
+
+	public function test_ellipsizing()
+	{
+		$strs = array(
+			'0'		=> array(
+				'this is my string'				=> '&hellip; my string',
+				"here's another one"			=> '&hellip;nother one',
+				'this one is just a bit longer'	=> '&hellip;bit longer',
+				'short'							=> 'short'
+			),
+			'.5'	=> array(
+				'this is my string'				=> 'this &hellip;tring',
+				"here's another one"			=> "here'&hellip;r one",
+				'this one is just a bit longer'	=> 'this &hellip;onger',
+				'short'							=> 'short'
+			),
+			'1'	=> array(
+				'this is my string'				=> 'this is my&hellip;',
+				"here's another one"			=> "here's ano&hellip;",
+				'this one is just a bit longer'	=> 'this one i&hellip;',
+				'short'							=> 'short'
+			),
+		);
+		
+		foreach ($strs as $pos => $s)
+		{
+			foreach ($s as $str => $expect)
+			{
+				$this->assertEquals($expect, ellipsize($str, 10, $pos));				
+			}
+		}
+	}
+
+	// ------------------------------------------------------------------------	
+
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/url_helper_test.php b/tests/codeigniter/helpers/url_helper_test.php
new file mode 100644
index 0000000..51a8cc7
--- /dev/null
+++ b/tests/codeigniter/helpers/url_helper_test.php
@@ -0,0 +1,72 @@
+<?php
+
+require_once(BASEPATH.'helpers/url_helper.php');
+
+class Url_helper_test extends CI_TestCase
+{
+	public function test_url_title()
+	{
+		$words = array(
+			'foo bar /' 	=> 'foo-bar',
+			'\  testing 12' => 'testing-12'
+		);
+
+		foreach ($words as $in => $out)
+		{
+			$this->assertEquals($out, url_title($in, 'dash', TRUE));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_url_title_extra_dashes()
+	{
+		$words = array(
+			'_foo bar_' 	=> 'foo_bar',
+			'_What\'s wrong with CSS?_' => 'Whats_wrong_with_CSS'
+		);
+
+		foreach ($words as $in => $out)
+		{
+			$this->assertEquals($out, url_title($in, 'underscore'));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_prep_url()
+	{
+		$this->assertEquals('http://codeigniter.com', prep_url('codeigniter.com'));
+		$this->assertEquals('http://www.codeigniter.com', prep_url('www.codeigniter.com'));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_auto_link_url()
+	{
+		$strings = array(
+			'www.codeigniter.com test' => '<a href="http://www.codeigniter.com">http://www.codeigniter.com</a> test',
+			'This is my noreply@codeigniter.com test' => 'This is my noreply@codeigniter.com test',
+			'<br />www.google.com' => '<br /><a href="http://www.google.com">http://www.google.com</a>',
+		);
+
+		foreach ($strings as $in => $out)
+		{
+			$this->assertEquals($out, auto_link($in, 'url'));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_pull_675()
+	{
+		$strings = array(
+			'<br />www.google.com' => '<br /><a href="http://www.google.com">http://www.google.com</a>',
+		);
+
+		foreach ($strings as $in => $out)
+		{
+			$this->assertEquals($out, auto_link($in, 'url'));
+		}
+	}
+}
\ No newline at end of file
diff --git a/tests/codeigniter/helpers/xml_helper_test.php b/tests/codeigniter/helpers/xml_helper_test.php
new file mode 100644
index 0000000..49f49e1
--- /dev/null
+++ b/tests/codeigniter/helpers/xml_helper_test.php
@@ -0,0 +1,13 @@
+<?php
+
+require_once(BASEPATH.'helpers/xml_helper.php');
+
+class Xml_helper_test extends CI_TestCase
+{
+	
+	public function test_xml_convert()
+	{
+		$this->assertEquals('&lt;tag&gt;my &amp; test &#45; &lt;/tag&gt;', xml_convert('<tag>my & test - </tag>'));
+	}
+	
+}
\ No newline at end of file
diff --git a/tests/codeigniter/libraries/Parser_test.php b/tests/codeigniter/libraries/Parser_test.php
new file mode 100644
index 0000000..b4580a4
--- /dev/null
+++ b/tests/codeigniter/libraries/Parser_test.php
@@ -0,0 +1,113 @@
+<?php
+
+require BASEPATH.'libraries/Parser.php';
+
+class Parser_test extends CI_TestCase
+{
+	
+	public function set_up()
+	{
+		$obj = new StdClass;
+		$obj->parser = new CI_Parser();
+		
+		$this->ci_instance($obj);
+		
+		$this->parser = $obj->parser;
+	}
+	// --------------------------------------------------------------------
+	
+	public function test_set_delimiters()
+	{
+		// Make sure default delimiters are there
+		$this->assertEquals('{', $this->parser->l_delim);
+		$this->assertEquals('}', $this->parser->r_delim);
+		
+		// Change them to square brackets
+		$this->parser->set_delimiters('[', ']');
+		
+		// Make sure they changed
+		$this->assertEquals('[', $this->parser->l_delim);
+		$this->assertEquals(']', $this->parser->r_delim);
+		
+		// Reset them
+		$this->parser->set_delimiters();
+		
+		// Make sure default delimiters are there
+		$this->assertEquals('{', $this->parser->l_delim);
+		$this->assertEquals('}', $this->parser->r_delim);
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function test_parse_simple_string()
+	{
+		$data = array(
+			'title' => 'Page Title',
+			'body' => 'Lorem ipsum dolor sit amet.'
+		);
+		
+		$template = "{title}\n{body}";
+		
+		$result = implode("\n", $data);
+		
+		$this->assertEquals($result, $this->parser->parse_string($template, $data, TRUE));
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function test_parse()
+	{
+		$this->_parse_no_template();
+		$this->_parse_var_pair();
+		$this->_mismatched_var_pair();
+	}
+	
+	// --------------------------------------------------------------------
+	
+	private function _parse_no_template()
+	{
+		$this->assertFalse($this->parser->parse_string('', '', TRUE));
+	}
+	
+	// --------------------------------------------------------------------
+	
+	private function _parse_var_pair()
+	{
+		$data = array(
+			'title'		=> 'Super Heroes',
+			'powers'	=> array(
+					array(
+						'invisibility'	=> 'yes',
+						'flying'		=> 'no'),
+			)
+		);
+		
+		$template = "{title}\n{powers}{invisibility}\n{flying}{/powers}";
+		
+		$result = "Super Heroes\nyes\nno";
+		
+		$this->assertEquals($result, $this->parser->parse_string($template, $data, TRUE));	
+	}
+	
+	// --------------------------------------------------------------------
+	
+	private function _mismatched_var_pair()
+	{
+		$data = array(
+			'title'		=> 'Super Heroes',
+			'powers'	=> array(
+					array(
+						'invisibility'	=> 'yes',
+						'flying'		=> 'no'),
+			)
+		);
+		
+		$template = "{title}\n{powers}{invisibility}\n{flying}";
+		
+		$result = "Super Heroes\n{powers}{invisibility}\n{flying}";
+		
+		$this->assertEquals($result, $this->parser->parse_string($template, $data, TRUE));			
+	}
+
+	// --------------------------------------------------------------------
+}
\ No newline at end of file
diff --git a/tests/codeigniter/libraries/Table_test.php b/tests/codeigniter/libraries/Table_test.php
new file mode 100644
index 0000000..0208a46
--- /dev/null
+++ b/tests/codeigniter/libraries/Table_test.php
@@ -0,0 +1,344 @@
+<?php
+
+require BASEPATH.'libraries/Table.php';
+
+class Table_test extends CI_TestCase
+{
+
+	public function set_up()
+	{
+		$obj = new StdClass;
+		$obj->table = new CI_table();
+		
+		$this->ci_instance($obj);
+		
+		$this->table = $obj->table;
+	}
+
+	
+	// Setter Methods
+	// --------------------------------------------------------------------
+	
+	public function test_set_template()
+	{
+		$this->assertFalse($this->table->set_template('not an array'));
+		
+		$template = array(
+			'a' => 'b'
+		);
+		
+		$this->table->set_template($template);
+		$this->assertEquals($template, $this->table->template);
+	}
+	
+	public function test_set_empty()
+	{
+		$this->table->set_empty('nada');
+		$this->assertEquals('nada', $this->table->empty_cells);
+	}
+	
+	public function test_set_caption()
+	{
+		$this->table->set_caption('awesome cap');
+		$this->assertEquals('awesome cap', $this->table->caption);
+	}
+	
+	
+	/*
+	 * @depends testPrepArgs
+	 */
+	public function test_set_heading()
+	{
+		// uses _prep_args internally, so we'll just do a quick
+		// check to verify that func_get_args and prep_args are
+		// being called.
+		
+		$this->table->set_heading('name', 'color', 'size');
+		
+		$this->assertEquals(
+			array(
+				array('data' => 'name'),
+				array('data' => 'color'),
+				array('data' => 'size')
+			),
+			$this->table->heading
+		);
+	}
+	
+	
+	/*
+	 * @depends testPrepArgs
+	 */
+	public function test_add_row()
+	{
+		// uses _prep_args internally, so we'll just do a quick
+		// check to verify that func_get_args and prep_args are
+		// being called.
+		
+		$this->table->add_row('my', 'pony', 'sings');
+		$this->table->add_row('your', 'pony', 'stinks');
+		$this->table->add_row('my pony', '>', 'your pony');
+		
+		$this->assertEquals(count($this->table->rows), 3);
+		
+		$this->assertEquals(
+			array(
+				array('data' => 'your'),
+				array('data' => 'pony'),
+				array('data' => 'stinks')
+			),
+			$this->table->rows[1]
+		);
+	}
+	
+	
+	// Uility Methods
+	// --------------------------------------------------------------------
+	
+	public function test_prep_args()
+	{
+		$expected = array(
+			array('data' => 'name'),
+			array('data' => 'color'),
+			array('data' => 'size')
+		);
+		
+		// test what would be discreet args,
+		// basically means a single array as the calling method
+		// will use func_get_args()
+		
+		$reflectionOfTable = new ReflectionClass($this->table);
+		$method = $reflectionOfTable->getMethod('_prep_args');
+		
+		$method->setAccessible(true);
+			
+		$this->assertEquals(
+			$expected,
+			$method->invokeArgs(
+				$this->table, array(array('name', 'color', 'size'), 'discreet')
+			)
+		);
+		
+		// test what would be a single array argument. Again, nested
+		// due to func_get_args on calling methods
+		$this->assertEquals(
+			$expected,
+			$method->invokeArgs(
+				$this->table, array(array('name', 'color', 'size'), 'array')
+			)
+		);
+		
+		
+		// with cell attributes
+		
+		// need to add that new argument row to our expected outcome
+		$expected[] = array('data' => 'weight', 'class' => 'awesome');
+
+		$this->assertEquals(
+			$expected,
+			$method->invokeArgs(
+				$this->table, array(array('name', 'color', 'size', array('data' => 'weight', 'class' => 'awesome')), 'attributes')
+			)
+		);
+	}
+	
+	public function test_default_template_keys()
+	{
+		$reflectionOfTable = new ReflectionClass($this->table);
+		$method = $reflectionOfTable->getMethod('_default_template');
+		
+		$method->setAccessible(true);
+		
+		$deft_template = $method->invoke($this->table);
+		$keys = array(
+			'table_open',
+			'thead_open', 'thead_close',
+			'heading_row_start', 'heading_row_end', 'heading_cell_start', 'heading_cell_end',
+			'tbody_open', 'tbody_close',
+			'row_start', 'row_end', 'cell_start', 'cell_end',
+			'row_alt_start', 'row_alt_end', 'cell_alt_start', 'cell_alt_end',
+			'table_close'
+		);
+		
+		foreach ($keys as $key)
+		{
+			$this->assertArrayHasKey($key, $deft_template);
+		}
+	}
+	
+	public function test_compile_template()
+	{
+		$reflectionOfTable = new ReflectionClass($this->table);
+		$method = $reflectionOfTable->getMethod('_compile_template');
+		
+		$method->setAccessible(true);
+		
+		$this->assertFalse($this->table->set_template('invalid_junk'));
+		
+		// non default key
+		$this->table->set_template(array('nonsense' => 'foo'));
+		$method->invoke($this->table);
+		
+		$this->assertArrayHasKey('nonsense', $this->table->template);
+		$this->assertEquals('foo', $this->table->template['nonsense']);
+		
+		// override default
+		$this->table->set_template(array('table_close' => '</table junk>'));
+		$method->invoke($this->table);
+		
+		$this->assertArrayHasKey('table_close', $this->table->template);
+		$this->assertEquals('</table junk>', $this->table->template['table_close']);
+	}
+	
+	public function test_make_columns()
+	{
+		// Test bogus parameters
+		$this->assertFalse($this->table->make_columns('invalid_junk'));
+		$this->assertFalse($this->table->make_columns(array()));
+		$this->assertFalse($this->table->make_columns(array('one', 'two'), '2.5'));
+		
+		
+		// Now on to the actual column creation
+		
+		$five_values = array(
+			'Laura', 'Red', '15',
+			'Katie', 'Blue'
+		);
+		
+		// No column count - no changes to the array
+		$this->assertEquals(
+			$five_values,
+			$this->table->make_columns($five_values)
+		);
+		
+		// Column count of 3 leaves us with one &nbsp;
+		$this->assertEquals(
+			array(
+				array('Laura', 'Red', '15'),
+				array('Katie', 'Blue', '&nbsp;')				
+			),
+			$this->table->make_columns($five_values, 3)
+		);
+	}
+	
+	public function test_clear()
+	{
+		$this->table->set_heading('Name', 'Color', 'Size');
+		
+		// Make columns changes auto_heading
+		$rows = $this->table->make_columns(array(
+			'Laura', 'Red', '15',
+			'Katie', 'Blue'
+		), 3);
+		
+		foreach ($rows as $row)
+		{
+			$this->table->add_row($row);
+		}
+		
+		$this->assertFalse($this->table->auto_heading);
+		$this->assertEquals(count($this->table->heading), 3);
+		$this->assertEquals(count($this->table->rows), 2);
+		
+		$this->table->clear();
+		
+		$this->assertTrue($this->table->auto_heading);
+		$this->assertEmpty($this->table->heading);
+		$this->assertEmpty($this->table->rows);
+	}
+	
+	
+	public function test_set_from_array()
+	{
+		$reflectionOfTable = new ReflectionClass($this->table);
+		$method = $reflectionOfTable->getMethod('_set_from_array');
+		
+		$method->setAccessible(true);
+				
+		$this->assertFalse($method->invokeArgs($this->table, array('bogus')));
+		$this->assertFalse($method->invoke($this->table, array()));
+		
+		$data = array(
+			array('name', 'color', 'number'),
+			array('Laura', 'Red', '22'),
+			array('Katie', 'Blue')				
+		);
+		
+		$method->invokeArgs($this->table, array($data, FALSE));
+		$this->assertEmpty($this->table->heading);
+		
+		$this->table->clear();
+		
+		$expected_heading = array(
+			array('data' => 'name'),
+			array('data' => 'color'),
+			array('data' => 'number')
+		);
+		
+		$expected_second = array(
+			array('data' => 'Katie'),
+			array('data' => 'Blue'),
+		);
+		
+		$method->invokeArgs($this->table, array($data));
+		$this->assertEquals(count($this->table->rows), 2);
+		
+		$this->assertEquals(
+			$expected_heading,
+			$this->table->heading
+		);
+		
+		$this->assertEquals(
+			$expected_second,
+			$this->table->rows[1]
+		);
+	}
+	
+	function test_set_from_object()
+	{
+		$reflectionOfTable = new ReflectionClass($this->table);
+		$method = $reflectionOfTable->getMethod('_set_from_object');
+		
+		$method->setAccessible(true);
+
+		// Make a stub of query instance
+		$query = new CI_TestCase();
+		$query->list_fields = function(){
+			return array('name', 'email');
+		};
+		$query->result_array = function(){
+			return array(
+					array('name' => 'John Doe', 'email' => 'john@doe.com'),
+					array('name' => 'Foo Bar', 'email' => 'foo@bar.com'),
+				);
+		};
+		$query->num_rows = function(){
+			return 2;
+		};
+
+		$expected_heading = array(
+			array('data' => 'name'),
+			array('data' => 'email')
+		);
+
+		$expected_second = array(
+			'name' => array('data' => 'Foo Bar'),
+			'email' => array('data' => 'foo@bar.com'),
+		);
+
+		$method->invokeArgs($this->table, array($query));
+
+		$this->assertEquals(
+			$expected_heading,
+			$this->table->heading
+		);
+		
+		$this->assertEquals(
+			$expected_second,
+			$this->table->rows[1]
+		);
+	}
+	
+	// Test main generate method
+	// --------------------------------------------------------------------
+}
\ No newline at end of file
diff --git a/tests/codeigniter/libraries/Typography_test.php b/tests/codeigniter/libraries/Typography_test.php
new file mode 100644
index 0000000..a0533ba
--- /dev/null
+++ b/tests/codeigniter/libraries/Typography_test.php
@@ -0,0 +1,191 @@
+<?php
+
+require BASEPATH.'libraries/Typography.php';
+
+class Typography_test extends CI_TestCase
+{
+
+	public function set_up()
+	{
+		$obj = new StdClass;
+		$obj->type = new CI_Typography();
+		
+		$this->ci_instance($obj);
+		
+		$this->type = $obj->type;
+	}
+
+	// --------------------------------------------------------------------
+
+	/**
+	 * Tests the format_characters() function.
+	 *
+	 * this can and should grow.
+	 */
+	public function test_format_characters()
+	{
+		$strs = array(
+			'"double quotes"' 				=> '&#8220;double quotes&#8221;',
+			'"testing" in "theory" that is' => '&#8220;testing&#8221; in &#8220;theory&#8221; that is',
+			"Here's what I'm" 				=> 'Here&#8217;s what I&#8217;m',
+			'&' 							=> '&amp;',
+			'&amp;' 						=> '&amp;',
+			'&nbsp;'						=> '&nbsp;',
+			'--'							=> '&#8212;',
+			'foo...'						=> 'foo&#8230;',
+			'foo..'							=> 'foo..',
+			'foo...bar.'					=> 'foo&#8230;bar.',
+			'test.  new'					=> 'test.&nbsp; new',
+		);	
+		
+		foreach ($strs as $str => $expected)
+		{
+			$this->assertEquals($expected, $this->type->format_characters($str));		
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_nl2br_except_pre()
+	{	
+		$str = <<<EOH
+Hello, I'm a happy string with some new lines.  
+
+I like to skip.
+
+Jump
+
+and sing.
+
+<pre>
+I am inside a pre tag.  Please don't mess with me.
+
+k?
+</pre>
+
+That's my story and I'm sticking to it.
+
+The End.
+EOH;
+
+		$expected = <<<EOH
+Hello, I'm a happy string with some new lines.  <br />
+<br />
+I like to skip.<br />
+<br />
+Jump<br />
+<br />
+and sing.<br />
+<br />
+<pre>
+I am inside a pre tag.  Please don't mess with me.
+
+k?
+</pre><br />
+<br />
+That's my story and I'm sticking to it.<br />
+<br />
+The End.
+EOH;
+
+		$this->assertEquals($expected, 
+							$this->type->nl2br_except_pre($str));
+	}
+
+	// --------------------------------------------------------------------
+	
+	public function test_auto_typography()
+	{
+		$this->_blank_string();
+		$this->_standardize_new_lines();
+		$this->_reduce_linebreaks();
+		$this->_remove_comments();
+		$this->_protect_pre();
+		$this->_no_opening_block();
+		$this->_protect_braced_quotes();
+	}
+
+	// --------------------------------------------------------------------
+	
+	private function _blank_string()
+	{
+		// Test blank string
+		$this->assertEquals('', $this->type->auto_typography(''));
+	}
+
+	// --------------------------------------------------------------------
+
+	private function _standardize_new_lines()
+	{
+		$strs = array(
+			"My string\rhas return characters"	=> "<p>My string<br />\nhas return characters</p>",
+			'This one does not!' 				=> '<p>This one does not!</p>'
+		);
+
+		foreach ($strs as $str => $expect)
+		{
+			$this->assertEquals($expect, $this->type->auto_typography($str));
+		}
+	}
+
+	// --------------------------------------------------------------------
+
+	private function _reduce_linebreaks()
+	{
+		$str = "This has way too many linebreaks.\n\n\n\nSee?";
+		$expect = "<p>This has way too many linebreaks.</p>\n\n<p>See?</p>";
+		
+		$this->assertEquals($expect, $this->type->auto_typography($str, TRUE));
+	}
+
+	// --------------------------------------------------------------------
+
+	private function _remove_comments()
+	{
+		$str = '<!-- I can haz comments? -->  But no!';
+		$expect = '<p><!-- I can haz comments? -->&nbsp; But no!</p>';
+		
+		$this->assertEquals($expect, $this->type->auto_typography($str));
+	}
+
+	// --------------------------------------------------------------------
+
+	private function _protect_pre()
+	{
+		$str = '<p>My Sentence</p><pre>var_dump($this);</pre>';
+		$expect = '<p>My Sentence</p><pre>var_dump($this);</pre>';
+		
+		$this->assertEquals($expect, $this->type->auto_typography($str));
+	}
+
+	// --------------------------------------------------------------------
+
+	private function _no_opening_block()
+	{
+		$str = 'My Sentence<pre>var_dump($this);</pre>';
+		$expect = '<p>My Sentence</p><pre>var_dump($this);</pre>';
+		
+		$this->assertEquals($expect, $this->type->auto_typography($str));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function _protect_braced_quotes()
+	{
+		$this->type->protect_braced_quotes = TRUE;
+		
+		$str = 'Test {parse="foobar"}';
+		$expect = '<p>Test {parse="foobar"}</p>';
+		
+		$this->assertEquals($expect, $this->type->auto_typography($str));
+
+		$this->type->protect_braced_quotes = FALSE;
+		
+		$str = 'Test {parse="foobar"}';
+		$expect = '<p>Test {parse=&#8220;foobar&#8221;}</p>';
+		
+		$this->assertEquals($expect, $this->type->auto_typography($str));
+
+
+	}
+}
\ No newline at end of file
diff --git a/tests/codeigniter/libraries/User_agent_test.php b/tests/codeigniter/libraries/User_agent_test.php
new file mode 100644
index 0000000..6f9e871
--- /dev/null
+++ b/tests/codeigniter/libraries/User_agent_test.php
@@ -0,0 +1,91 @@
+<?php
+
+require BASEPATH.'libraries/User_agent.php';
+
+// This class needs some work...
+
+class UserAgent_test extends CI_TestCase
+{
+	protected $_user_agent = 'Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_6_7; en-us) AppleWebKit/533.20.25 (KHTML, like Gecko) Version/5.0.4 Safari/533.20.27';
+	protected $_mobile_ua = 'Mozilla/5.0 (iPhone; U; CPU iPhone OS 4_1 like Mac OS X; en-us) AppleWebKit/532.9 (KHTML, like Gecko) Version/4.0.5 Mobile/8B117 Safari/6531.22.7';
+
+	public function set_up()
+	{
+		// set a baseline user agent
+		$_SERVER['HTTP_USER_AGENT'] = $this->_user_agent;
+
+		$obj = new StdClass;
+		$obj->agent = new CI_User_agent();
+
+		$this->ci_instance($obj);
+
+		$this->agent = $obj->agent;
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_accept_lang()
+	{
+		$_SERVER['HTTP_ACCEPT_LANGUAGE'] = 'en';
+		$this->assertTrue($this->agent->accept_lang());
+		unset($_SERVER['HTTP_ACCEPT_LANGUAGE']);
+		$this->assertTrue($this->agent->accept_lang('en'));
+		$this->assertFalse($this->agent->accept_lang('fr'));
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_mobile()
+	{
+		// Mobile Not Set
+		$_SERVER['HTTP_USER_AGENT'] = $this->_mobile_ua;
+		$this->assertEquals('', $this->agent->mobile());
+		unset($_SERVER['HTTP_USER_AGENT']);
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_util_is_functions()
+	{
+		$this->assertTrue($this->agent->is_browser());
+		$this->assertFalse($this->agent->is_robot());
+		$this->assertFalse($this->agent->is_mobile());
+		$this->assertFalse($this->agent->is_referral());
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_agent_string()
+	{
+		$this->assertEquals($this->_user_agent, $this->agent->agent_string());
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_browser_info()
+	{
+		$this->assertEquals('Mac OS X', $this->agent->platform());
+		$this->assertEquals('Safari', $this->agent->browser());
+		$this->assertEquals('533.20.27', $this->agent->version());
+		$this->assertEquals('', $this->agent->robot());
+		$this->assertEquals('', $this->agent->referrer());
+	}
+
+	// --------------------------------------------------------------------
+
+	public function test_charsets()
+	{
+		$_SERVER['HTTP_ACCEPT_CHARSET'] = 'utf8';
+
+		$charsets = $this->agent->charsets();
+
+		$this->assertEquals('utf8', $charsets[0]);
+
+		unset($_SERVER['HTTP_ACCEPT_CHARSET']);
+
+		$this->assertFalse($this->agent->accept_charset());
+	}
+
+	// --------------------------------------------------------------------
+
+}
\ No newline at end of file
diff --git a/tests/lib/ci_testcase.php b/tests/lib/ci_testcase.php
new file mode 100644
index 0000000..afccee0
--- /dev/null
+++ b/tests/lib/ci_testcase.php
@@ -0,0 +1,194 @@
+<?php
+
+
+// Need a way to change dependencies (core libs and laoded libs)
+// Need a way to set the CI class
+
+class CI_TestCase extends PHPUnit_Framework_TestCase {
+	
+	protected $ci_config;
+	protected $ci_instance;
+	protected static $ci_test_instance;
+		
+	private $global_map = array(
+		'benchmark'	=> 'bm',
+		'config'	=> 'cfg',
+		'hooks'		=> 'ext',
+		'utf8'		=> 'uni',
+		'router'	=> 'rtr',
+		'output'	=> 'out',
+		'security'	=> 'sec',
+		'input'		=> 'in',
+		'lang'		=> 'lang',
+		// @todo the loader is an edge case
+		'loader'	=> 'load',
+		'model'		=> 'model'
+	);
+	
+	// --------------------------------------------------------------------
+	
+	public function __construct()
+	{
+		parent::__construct();
+		
+		$this->ci_config = array();
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function setUp()
+	{
+		if (method_exists($this, 'set_up'))
+		{
+			$this->set_up();
+		}
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public function tearDown() 
+	{
+		if (method_exists($this, 'tear_down'))
+		{
+			$this->tear_down();
+		}
+	}
+	
+	// --------------------------------------------------------------------
+	
+	function ci_set_config($key, $val = '')
+	{
+		if (is_array($key))
+		{
+			$this->ci_config = $key;
+		}
+		else
+		{
+			$this->ci_config[$key] = $val;
+		}
+	}
+	
+	// --------------------------------------------------------------------
+	
+	function ci_instance($obj = FALSE)
+	{
+		if ( ! is_object($obj))
+		{
+			return $this->ci_instance;
+		}
+		
+		$this->ci_instance = $obj;
+	}
+	
+	// --------------------------------------------------------------------
+	
+	function ci_instance_var($name, $obj = FALSE)
+	{
+		if ( ! is_object($obj))
+		{
+			return $this->ci_instance->$name;
+		}
+		
+		$this->ci_instance->$name =& $obj;
+	}
+	
+	// --------------------------------------------------------------------
+
+	/**
+	 * Grab a core class
+	 *
+	 * Loads the correct core class without extensions
+	 * and returns a reference to the class name in the
+	 * globals array with the correct key. This way the
+	 * test can modify the variable it assigns to and
+	 * still maintain the global.
+	 */
+	function &ci_core_class($name)
+	{
+		$name = strtolower($name);
+		
+		if (isset($this->global_map[$name]))
+		{
+			$class_name = ucfirst($name);
+			$global_name = $this->global_map[$name];
+		}
+		elseif (in_array($name, $this->global_map))
+		{
+			$class_name = ucfirst(array_search($name, $this->global_map));
+			$global_name = $name;
+		}
+		else
+		{
+			throw new Exception('Not a valid core class.');
+		}
+		
+		if ( ! class_exists('CI_'.$class_name))
+		{
+			require_once BASEPATH.'core/'.$class_name.'.php';
+		}
+		
+		$GLOBALS[strtoupper($global_name)] = 'CI_'.$class_name;
+		return $GLOBALS[strtoupper($global_name)];
+	}
+	
+	// --------------------------------------------------------------------
+	
+	// convenience function for global mocks
+	function ci_set_core_class($name, $obj)
+	{
+		$orig =& $this->ci_core_class($name);
+		$orig = $obj;
+	}
+	
+	// --------------------------------------------------------------------
+	// Internals
+	// --------------------------------------------------------------------
+	
+	/**
+	 * Overwrite runBare
+	 *
+	 * PHPUnit instantiates the test classes before
+	 * running them individually. So right before a test
+	 * runs we set our instance. Normally this step would
+	 * happen in setUp, but someone is bound to forget to
+	 * call the parent method and debugging this is no fun.
+	 */
+	public function runBare()
+	{
+		self::$ci_test_instance = $this;
+		parent::runBare();
+	}
+	
+	// --------------------------------------------------------------------
+	
+	public static function instance()
+	{
+		return self::$ci_test_instance;
+	}
+	
+	// --------------------------------------------------------------------
+	
+	function ci_get_config()
+	{
+		return $this->ci_config;
+	}
+
+	// --------------------------------------------------------------------
+	
+	/**
+	 * This overload is useful to create a stub, that need to have a specific method.
+	 */
+	function __call($method, $args)
+	{
+		if ($this->{$method} instanceof Closure) 
+		{
+			return call_user_func_array($this->{$method},$args);
+		} 
+		else 
+		{
+			return parent::__call($method, $args);
+		}
+	}
+}
+
+// EOF
\ No newline at end of file
diff --git a/tests/lib/common.php b/tests/lib/common.php
new file mode 100644
index 0000000..4a83258
--- /dev/null
+++ b/tests/lib/common.php
@@ -0,0 +1,132 @@
+<?php
+
+// Set up the global CI functions in their most minimal core representation
+
+function &get_instance() 
+{
+	$test = CI_TestCase::instance();
+	$instance = $test->ci_instance();
+	return $instance;
+}
+
+// --------------------------------------------------------------------
+
+function &get_config() {
+	$test = CI_TestCase::instance();
+	$config = $test->ci_get_config();
+		
+	return $config;
+}
+
+function config_item($item)
+{
+	$config =& get_config();
+	
+	if ( ! isset($config[$item]))
+	{
+		return FALSE;
+	}
+	
+	return $config[$item];
+}
+
+// --------------------------------------------------------------------
+
+function load_class($class, $directory = 'libraries', $prefix = 'CI_')
+{
+	if ($directory != 'core' OR $prefix != 'CI_')
+	{
+		throw new Exception('Not Implemented: Non-core load_class()');
+	}
+	
+	$test = CI_TestCase::instance();
+	
+	$obj =& $test->ci_core_class($class);
+	
+	if (is_string($obj))
+	{
+		throw new Exception('Bad Isolation: Use ci_set_core_class to set '.$class.'');
+	}
+	
+	return $obj;
+}
+
+// This is sort of meh. Should probably be mocked up with
+// controllable output, so that we can test some of our
+// security code. The function itself will be tested in the
+// bootstrap testsuite.
+// --------------------------------------------------------------------
+
+function remove_invisible_characters($str, $url_encoded = TRUE)
+{
+	$non_displayables = array();
+	
+	// every control character except newline (dec 10)
+	// carriage return (dec 13), and horizontal tab (dec 09)
+	
+	if ($url_encoded)
+	{
+		$non_displayables[] = '/%0[0-8bcef]/';	// url encoded 00-08, 11, 12, 14, 15
+		$non_displayables[] = '/%1[0-9a-f]/';	// url encoded 16-31
+	}
+	
+	$non_displayables[] = '/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]+/S';	// 00-08, 11, 12, 14-31, 127
+
+	do
+	{
+		$str = preg_replace($non_displayables, '', $str, -1, $count);
+	}
+	while ($count);
+
+	return $str;
+}
+
+
+// Clean up error messages
+// --------------------------------------------------------------------
+
+function show_error($message, $status_code = 500, $heading = 'An Error Was Encountered')
+{
+	throw new RuntimeException('CI Error: '.$message);
+}
+
+function show_404($page = '', $log_error = TRUE)
+{
+	throw new RuntimeException('CI Error: 404');
+}
+
+function _exception_handler($severity, $message, $filepath, $line)
+{
+	throw new RuntimeException('CI Exception: '.$message.' | '.$filepath.' | '.$line);
+}
+
+
+// We assume a few things about our environment ...
+// --------------------------------------------------------------------
+
+function is_php($version = '5.0.0')
+{
+	return ! (version_compare(PHP_VERSION, $version) < 0);
+}
+
+function is_really_writable($file)
+{
+	return is_writable($file);
+}
+
+function is_loaded()
+{
+	throw new Exception('Bad Isolation: mock up environment');
+}
+
+function log_message($level = 'error', $message, $php_error = FALSE)
+{
+	return TRUE;
+}
+
+function set_status_header($code = 200, $text = '')
+{
+	return TRUE;
+}
+
+// EOF
diff --git a/tests/phpunit.xml b/tests/phpunit.xml
new file mode 100644
index 0000000..abb9881
--- /dev/null
+++ b/tests/phpunit.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit 
+	bootstrap="Bootstrap.php"
+	colors="true"
+	convertNoticesToExceptions="true"
+	convertWarningsToExceptions="true"
+	stopOnError="false"
+	stopOnFailure="false"
+	stopOnIncomplete="false"
+	stopOnSkipped="false">
+	<testsuites>
+		<testsuite name="CodeIgniter Core Test Suite">
+			<file>codeigniter/Setup_test.php</file>
+			<directory suffix="test.php">codeigniter/core</directory>
+			<directory suffix="test.php">codeigniter/helpers</directory>
+			<directory suffix="test.php">codeigniter/libraries</directory>
+			<!-- We'll worry about these later ...
+			<directory suffix="test.php">codeigniter/libraries</directory>
+			<directory suffix="test.php">codeigniter/helpers</directory>
+			-->
+			
+		</testsuite>
+	</testsuites>
+	<filters>
+		<blacklist>
+			<directory suffix=".php">PEAR_INSTALL_DIR</directory>
+			<directory suffix=".php">PHP_LIBDIR</directory>
+			<directory suffix=".php">PROJECT_BASE.'tests'</directory>
+			<directory suffix=".php">'../system/core/CodeIgniter.php'</directory>
+		</blacklist>
+		<whitelist>
+			<!--
+			<directory suffix=".php">'../system/core'</directory>
+			-->
+		</whitelist>
+	</filters>
+</phpunit>
\ No newline at end of file
diff --git a/user_guide_src/source/changelog.rst b/user_guide_src/source/changelog.rst
index f9e7422..ed0b710 100644
--- a/user_guide_src/source/changelog.rst
+++ b/user_guide_src/source/changelog.rst
@@ -43,8 +43,11 @@
    -  Changed humanize to include a second param for the separator.
    -  Refactored ``plural()`` and ``singular()`` to avoid double pluralization and support more words.
    -  Added an optional third parameter to ``force_download()`` that enables/disables sending the actual file MIME type in the Content-Type header (disabled by default).
+   -  Added an optional third parameter to ``timespan()`` that constrains the number of time units displayed.
    -  Added a work-around in force_download() for a bug Android <= 2.1, where the filename extension needs to be in uppercase.
    -  form_dropdown() will now also take an array for unity with other form helpers.
+   -  set_realpath() can now also handle file paths as opposed to just directories.
+   -  do_hash() now uses PHP's native hash() function, supporting more algorithms.
 
 -  Database
 
@@ -89,6 +92,7 @@
    -  Minor speed optimizations and method & property visibility declarations in the Calendar Library.
    -  Removed SHA1 function in the :doc:`Encryption Library <libraries/encryption>`.
    -  Added $config['csrf_regeneration'] to the CSRF protection in the :doc:`Security library <libraries/security>`, which makes token regeneration optional.
+   -  Added all_flashdata() method to session class. Returns an associative array of only flashdata.
    -  Allowed for setting table class defaults in a config file.
    -  Form Validation library now allows setting of error delimiters in the config file via $config['error_prefix'] and $config['error_suffix'].
    -  Added function error_array() to return all error messages as an array in the Form_validation class.
@@ -106,6 +110,7 @@
    -  $config['rewrite_short_tags'] now has no effect when using PHP 5.4 as *<?=* will always be available.
    -  Added method() to CI_Input to retrieve $_SERVER['REQUEST_METHOD'].
    -  Modified valid_ip() to use PHP's filter_var() in the :doc:`Input Library <libraries/input>`.
+   -  Added support for HTTP-Only cookies with new config option ``cookie_httponly`` (default FALSE).
 
 Bug fixes for 3.0
 ------------------
@@ -157,6 +162,7 @@
 -  Fixed a bug in the :doc:`Session Library <libraries/sessions>` where a PHP E_NOTICE error was triggered by _unserialize() due to results from databases such as MSSQL and Oracle being space-padded on the right.
 -  Fixed a bug (#501) - set_rules() to check if the request method is not 'POST' before aborting, instead of depending on count($_POST) in the :doc:`Form Validation Library <libraries/form_validation>`.
 -  Fixed a bug (#940) - csrf_verify() used to set the CSRF cookie while processing a POST request with no actual POST data, which resulted in validating a request that should be considered invalid.
+-  Fixed a bug in PostgreSQL's escape_str() where it didn't properly escape LIKE wild characters.
 
 Version 2.1.1
 =============
diff --git a/user_guide_src/source/database/active_record.rst b/user_guide_src/source/database/active_record.rst
index c04e67d..e328c11 100644
--- a/user_guide_src/source/database/active_record.rst
+++ b/user_guide_src/source/database/active_record.rst
@@ -68,7 +68,7 @@
 	// Produces string: SELECT * FROM mytable
 
 The second parameter enables you to set whether or not the active record query
-will be reset (by default it will be&mdash;just like `$this->db->get()`)::
+will be reset (by default it will be just like `$this->db->get()`)::
 
 	echo $this->db->limit(10,20)->get_compiled_select('mytable', FALSE);
 	// Produces string: SELECT * FROM mytable LIMIT 20, 10
@@ -533,7 +533,7 @@
 **************
 
 Query grouping allows you to create groups of WHERE clauses by enclosing them in parentheses. This will allow
-you to create queries with complex WHERE clauses. Nested groups are supported. Example:
+you to create queries with complex WHERE clauses. Nested groups are supported. Example::
 
 	$this->db->select('*')->from('my_table')
 		->group_start()
@@ -921,9 +921,9 @@
 multiple functions. Consider this example::
 
 	$query = $this->db->select('title')
-				->where('id', $id)
-				->limit(10, 20)
-				->get('mytable');
+			->where('id', $id)
+			->limit(10, 20)
+			->get('mytable');
 
 .. _ar-caching:
 
diff --git a/user_guide_src/source/helpers/date_helper.rst b/user_guide_src/source/helpers/date_helper.rst
index ad06dd6..b21d147 100644
--- a/user_guide_src/source/helpers/date_helper.rst
+++ b/user_guide_src/source/helpers/date_helper.rst
@@ -255,14 +255,16 @@
 
 The first parameter must contain a Unix timestamp. The second parameter
 must contain a timestamp that is greater that the first timestamp. If
-the second parameter empty, the current time will be used. The most
-common purpose for this function is to show how much time has elapsed
-from some point in time in the past to now. 
+the second parameter empty, the current time will be used. The third 
+parameter is optional and limits the number of time units to display. 
+The most common purpose for this function is to show how much time has 
+elapsed from some point in time in the past to now. 
 
-.. php:method:: timespan($seconds = 1, $time = '')
+.. php:method:: timespan($seconds = 1, $time = '', $units = '')
 
 	:param integer 	$seconds: a number of seconds
 	:param string 	$time: Unix timestamp
+	:param integer 	$units: a number of time units to display
 	:returns: string
 
 Example
@@ -271,7 +273,8 @@
 
 	$post_date = '1079621429';
 	$now = time();
-	echo timespan($post_date, $now);
+	$units = 2;
+	echo timespan($post_date, $now, $units);
 
 .. note:: The text generated by this function is found in the following language
 	file: language/<your_lang>/date_lang.php
diff --git a/user_guide_src/source/helpers/form_helper.rst b/user_guide_src/source/helpers/form_helper.rst
index 4cb0cfd..a110f3c 100644
--- a/user_guide_src/source/helpers/form_helper.rst
+++ b/user_guide_src/source/helpers/form_helper.rst
@@ -177,7 +177,7 @@
 	/*
 		Would produce:
 
-		<input type="text" name="username" id="username" value="johndoe" maxlength="100" size="50" style="width:50%" />
+		<input type="text" name="username" value="johndoe" id="username" maxlength="100" size="50" style="width:50%"  />
 	*/
 
 If you would like your form to contain some additional data, like
@@ -325,7 +325,7 @@
 
 	$string = "</div></div>";
 	echo form_fieldset_close($string);
-	// Would produce: </fieldset> </div></div>
+	// Would produce: </fieldset></div></div>
 
 form_checkbox()
 ===============
diff --git a/user_guide_src/source/helpers/path_helper.rst b/user_guide_src/source/helpers/path_helper.rst
index 1a70af4..847f5a0 100644
--- a/user_guide_src/source/helpers/path_helper.rst
+++ b/user_guide_src/source/helpers/path_helper.rst
@@ -28,10 +28,16 @@
 
 ::
 
-	$directory = '/etc/passwd'; 
-	echo set_realpath($directory); // returns "/etc/passwd"  
-	$non_existent_directory = '/path/to/nowhere'; 
-	echo set_realpath($non_existent_directory, TRUE); // returns an error, as the path could not be resolved  
-	echo set_realpath($non_existent_directory, FALSE); // returns "/path/to/nowhere"   
+	$file = '/etc/php5/apache2/php.ini';
+	echo set_realpath($file); // returns "/etc/php5/apache2/php.ini"
 
+	$non_existent_file = '/path/to/non-exist-file.txt';
+	echo set_realpath($non_existent_file, TRUE);	// shows an error, as the path cannot be resolved
+	echo set_realpath($non_existent_file, FALSE);	// returns "/path/to/non-exist-file.txt"
 
+	$directory = '/etc/php5';
+	echo set_realpath($directory);	// returns "/etc/php5/"
+	
+	$non_existent_directory = '/path/to/nowhere';
+	echo set_realpath($non_existent_directory, TRUE);	// shows an error, as the path cannot be resolved
+	echo set_realpath($non_existent_directory, FALSE);	// returns "/path/to/nowhere"
diff --git a/user_guide_src/source/helpers/security_helper.rst b/user_guide_src/source/helpers/security_helper.rst
index 01018c6..b1bcf2b 100644
--- a/user_guide_src/source/helpers/security_helper.rst
+++ b/user_guide_src/source/helpers/security_helper.rst
@@ -34,8 +34,9 @@
 do_hash()
 =========
 
-Permits you to create SHA1 or MD5 one way hashes suitable for encrypting
-passwords. Will create SHA1 by default. Examples
+Permits you to create one way hashes suitable for encrypting
+passwords. Will create SHA1 by default. See `hash_algos() <http://php.net/function.hash_algos>`_
+for a full list of supported algorithms.
 
 ::
 
@@ -43,7 +44,7 @@
 	$str = do_hash($str, 'md5'); // MD5
 
 .. note:: This function was formerly named dohash(), which has been
-	deprecated in favor of `do_hash()`.
+	removed in favor of `do_hash()`.
 
 strip_image_tags()
 ==================
diff --git a/user_guide_src/source/helpers/string_helper.rst b/user_guide_src/source/helpers/string_helper.rst
index dc70e46..2d23fb0 100644
--- a/user_guide_src/source/helpers/string_helper.rst
+++ b/user_guide_src/source/helpers/string_helper.rst
@@ -108,6 +108,36 @@
 	$string = "http://example.com//index.php";
 	echo reduce_double_slashes($string); // results in "http://example.com/index.php"
 
+strip_slashes()
+===============
+
+Removes any slashes from a string. Example
+
+::
+
+	$str = "Is your name O\'reilly?";
+	echo strip_slashes($str); // results in Is your name O'reilly?
+
+You can also use an array. Example
+
+::
+	
+	$str = array(
+		'question'  => 'Is your name O\'reilly?',
+		'answer' => 'No, my name is O\'connor.'
+	);
+	
+	$str = strip_slashes($str);
+	
+The above will return the following array:
+
+::
+
+	array(
+		'question'  => "Is your name O'reilly?",
+		'answer' => "No, my name is O'connor."
+	);
+
 trim_slashes()
 ==============
 
diff --git a/user_guide_src/source/libraries/sessions.rst b/user_guide_src/source/libraries/sessions.rst
index ef32f5d..e8332ee 100644
--- a/user_guide_src/source/libraries/sessions.rst
+++ b/user_guide_src/source/libraries/sessions.rst
@@ -209,6 +209,10 @@
 To read a flashdata variable::
 
 	$this->session->flashdata('item');
+	
+An array of all flashdata can be retrieved as follows::
+
+	$this->session->all_flashdata();
 
 
 If you find that you need to preserve a flashdata variable through an
